removed ASSERT_NO_THROW

modules/gpu/test/test_calib3d.cpp

@@ -77,14 +77,12 @@ TEST_P(StereoBlockMatching, Regression)
 {    
     cv::Mat disp;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_disp;
-        cv::gpu::StereoBM_GPU bm(0, 128, 19);
+    cv::gpu::GpuMat dev_disp;
+    cv::gpu::StereoBM_GPU bm(0, 128, 19);
 
-        bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
-        
-        dev_disp.download(disp);
-    );
+    bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+    
+    dev_disp.download(disp);
 
     disp.convertTo(disp, img_template.type());
     
@@ -124,14 +122,12 @@ TEST_P(StereoBeliefPropagation, Regression)
 {
     cv::Mat disp;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_disp;
-        cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+    cv::gpu::GpuMat dev_disp;
+    cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
 
-        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
-        
-        dev_disp.download(disp);
-    );
+    bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+    
+    dev_disp.download(disp);
 
     disp.convertTo(disp, img_template.type());
     
@@ -175,14 +171,12 @@ TEST_P(StereoConstantSpaceBP, Regression)
 {
     cv::Mat disp;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_disp;
-        cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
+    cv::gpu::GpuMat dev_disp;
+    cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
 
-        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
-        
-        dev_disp.download(disp);
-    );
+    bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+    
+    dev_disp.download(disp);
 
     disp.convertTo(disp, img_template.type());
     
@@ -229,14 +223,12 @@ struct ProjectPoints : TestWithParam<cv::gpu::DeviceInfo>
 TEST_P(ProjectPoints, Accuracy) 
 {
     cv::Mat dst;
+   
+    cv::gpu::GpuMat d_dst;
 
-    ASSERT_NO_THROW(   
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::projectPoints(cv::gpu::GpuMat(src), rvec, tvec, camera_mat, cv::Mat(), d_dst);
+    cv::gpu::projectPoints(cv::gpu::GpuMat(src), rvec, tvec, camera_mat, cv::Mat(), d_dst);
 
-        d_dst.download(dst);
-    );
+    d_dst.download(dst);
 
     ASSERT_EQ(dst_gold.size(), dst.cols);
     ASSERT_EQ(1, dst.rows);
@@ -286,13 +278,11 @@ TEST_P(TransformPoints, Accuracy)
 {
     cv::Mat dst;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_dst;
 
-        cv::gpu::transformPoints(cv::gpu::GpuMat(src), rvec, tvec, d_dst);
+    cv::gpu::transformPoints(cv::gpu::GpuMat(src), rvec, tvec, d_dst);
 
-        d_dst.download(dst);
-    );
+    d_dst.download(dst);
     
     ASSERT_EQ(src.size(), dst.size());
     ASSERT_EQ(src.type(), dst.type());
@@ -356,10 +346,8 @@ TEST_P(SolvePnPRansac, Accuracy)
     cv::Mat rvec, tvec;
     std::vector<int> inliers;
 
-    ASSERT_NO_THROW(
-        cv::gpu::solvePnPRansac(object, cv::Mat(1, image_vec.size(), CV_32FC2, &image_vec[0]), camera_mat, 
-                                cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec, false, 200, 2.f, 100, &inliers);
-    );
+    cv::gpu::solvePnPRansac(object, cv::Mat(1, image_vec.size(), CV_32FC2, &image_vec[0]), camera_mat, 
+                            cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec, false, 200, 2.f, 100, &inliers);
 
     ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3f);
     ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3f);

modules/gpu/test/test_filters.cpp

@@ -107,13 +107,11 @@ TEST_P(Blur, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::blur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize);
+    cv::gpu::blur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 1.0);
 }
@@ -122,13 +120,11 @@ TEST_P(Blur, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::blur(loadMat(img_gray, useRoi), dev_dst_gray, ksize);
+    cv::gpu::blur(loadMat(img_gray, useRoi), dev_dst_gray, ksize);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 1.0);
 }
@@ -186,13 +182,11 @@ TEST_P(Sobel, Rgba)
 
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::Sobel(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy, ksize);
+    cv::gpu::Sobel(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy, ksize);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 0.0);
 }
@@ -204,13 +198,11 @@ TEST_P(Sobel, Gray)
 
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::Sobel(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy, ksize);
+    cv::gpu::Sobel(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy, ksize);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 0.0);
 }
@@ -268,13 +260,11 @@ TEST_P(Scharr, Rgba)
 
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::Scharr(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy);
+    cv::gpu::Scharr(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
 }
@@ -286,13 +276,11 @@ TEST_P(Scharr, Gray)
 
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::Scharr(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy);
+    cv::gpu::Scharr(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
 }
@@ -348,13 +336,11 @@ TEST_P(GaussianBlur, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::GaussianBlur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize, sigma1, sigma2);
+    cv::gpu::GaussianBlur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize, sigma1, sigma2);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 3.0);
 }
@@ -363,13 +349,11 @@ TEST_P(GaussianBlur, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::GaussianBlur(loadMat(img_gray, useRoi), dev_dst_gray, ksize, sigma1, sigma2);
+    cv::gpu::GaussianBlur(loadMat(img_gray, useRoi), dev_dst_gray, ksize, sigma1, sigma2);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 3.0);
 }
@@ -417,13 +401,11 @@ TEST_P(Laplacian, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::Laplacian(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, ksize);
+    cv::gpu::Laplacian(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, ksize);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
 }
@@ -432,13 +414,11 @@ TEST_P(Laplacian, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::Laplacian(loadMat(img_gray, useRoi), dev_dst_gray, -1, ksize);
+    cv::gpu::Laplacian(loadMat(img_gray, useRoi), dev_dst_gray, -1, ksize);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
 }
@@ -488,13 +468,11 @@ TEST_P(Erode, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::erode(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
+    cv::gpu::erode(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
 }
@@ -503,13 +481,11 @@ TEST_P(Erode, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::erode(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
+    cv::gpu::erode(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
 }
@@ -558,13 +534,11 @@ TEST_P(Dilate, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::dilate(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
+    cv::gpu::dilate(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
 }
@@ -573,13 +547,11 @@ TEST_P(Dilate, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::dilate(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
+    cv::gpu::dilate(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
 }
@@ -630,13 +602,11 @@ TEST_P(MorphEx, Rgba)
 {
     cv::Mat dst_rgba;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_rgba;
+    cv::gpu::GpuMat dev_dst_rgba;
 
-        cv::gpu::morphologyEx(loadMat(img_rgba, useRoi), dev_dst_rgba, morphOp, kernel);
+    cv::gpu::morphologyEx(loadMat(img_rgba, useRoi), dev_dst_rgba, morphOp, kernel);
 
-        dev_dst_rgba.download(dst_rgba);
-    );
+    dev_dst_rgba.download(dst_rgba);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 4, 0.0);
 }
@@ -645,13 +615,11 @@ TEST_P(MorphEx, Gray)
 {
     cv::Mat dst_gray;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_dst_gray;
+    cv::gpu::GpuMat dev_dst_gray;
 
-        cv::gpu::morphologyEx(loadMat(img_gray, useRoi), dev_dst_gray, morphOp, kernel);
+    cv::gpu::morphologyEx(loadMat(img_gray, useRoi), dev_dst_gray, morphOp, kernel);
 
-        dev_dst_gray.download(dst_gray);
-    );
+    dev_dst_gray.download(dst_gray);
 
     EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 4, 0.0);
 }

modules/gpu/test/test_hog.cpp

@@ -186,10 +186,8 @@ struct Detect : TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(Detect, Accuracy)
 {
-    ASSERT_NO_THROW(
-        CV_GpuHogDetectTestRunner runner;
-        runner.run();
-    );
+    CV_GpuHogDetectTestRunner runner;
+    runner.run();
 }
 
 INSTANTIATE_TEST_CASE_P(HOG, Detect, ALL_DEVICES);
@@ -316,10 +314,8 @@ struct GetDescriptors : TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(GetDescriptors, Accuracy)
 {
-    ASSERT_NO_THROW(
-        CV_GpuHogGetDescriptorsTestRunner runner;
-        runner.run();
-    );
+    CV_GpuHogGetDescriptorsTestRunner runner;
+    runner.run();
 }
 
 INSTANTIATE_TEST_CASE_P(HOG, GetDescriptors, ALL_DEVICES);

modules/gpu/test/test_matop.cpp

@@ -90,17 +90,15 @@ TEST_P(Merge, Accuracy)
 
     cv::Mat dst;
 
-    ASSERT_NO_THROW(
-        std::vector<cv::gpu::GpuMat> dev_src;
-        cv::gpu::GpuMat dev_dst;
+    std::vector<cv::gpu::GpuMat> dev_src;
+    cv::gpu::GpuMat dev_dst;
 
-        for (size_t i = 0; i < src.size(); ++i)
-            dev_src.push_back(loadMat(src[i], useRoi));
+    for (size_t i = 0; i < src.size(); ++i)
+        dev_src.push_back(loadMat(src[i], useRoi));
 
-        cv::gpu::merge(dev_src, dev_dst); 
+    cv::gpu::merge(dev_src, dev_dst); 
 
-        dev_dst.download(dst);
-    );
+    dev_dst.download(dst);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
@@ -149,16 +147,14 @@ TEST_P(Split, Accuracy)
 
     std::vector<cv::Mat> dst;
     
-    ASSERT_NO_THROW(
-        std::vector<cv::gpu::GpuMat> dev_dst;
+    std::vector<cv::gpu::GpuMat> dev_dst;
 
-        cv::gpu::split(loadMat(src, useRoi), dev_dst);
+    cv::gpu::split(loadMat(src, useRoi), dev_dst);
 
-        dst.resize(dev_dst.size());
+    dst.resize(dev_dst.size());
 
-        for (size_t i = 0; i < dev_dst.size(); ++i)
-            dev_dst[i].download(dst[i]);
-    );
+    for (size_t i = 0; i < dev_dst.size(); ++i)
+        dev_dst[i].download(dst[i]);
 
     ASSERT_EQ(dst_gold.size(), dst.size());
 
@@ -207,15 +203,13 @@ TEST_P(SplitMerge, Consistency)
 
     cv::Mat final;
 
-    ASSERT_NO_THROW(
-        std::vector<cv::gpu::GpuMat> dev_vec;
-        cv::gpu::GpuMat dev_final;
+    std::vector<cv::gpu::GpuMat> dev_vec;
+    cv::gpu::GpuMat dev_final;
 
-        cv::gpu::split(loadMat(orig), dev_vec);    
-        cv::gpu::merge(dev_vec, dev_final);
+    cv::gpu::split(loadMat(orig), dev_vec);    
+    cv::gpu::merge(dev_vec, dev_final);
 
-        dev_final.download(final);
-    );
+    dev_final.download(final);
 
     EXPECT_MAT_NEAR(orig, final, 0.0);
 }
@@ -261,14 +255,12 @@ TEST_P(SetTo, Zero)
 
     cv::Mat mat;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
+    cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
 
-        mat_gold.setTo(zero);
-        dev_mat.setTo(zero);
+    mat_gold.setTo(zero);
+    dev_mat.setTo(zero);
 
-        dev_mat.download(mat);
-    );
+    dev_mat.download(mat);
 
     EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
 }
@@ -282,14 +274,12 @@ TEST_P(SetTo, SameVal)
 
     cv::Mat mat;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_mat(mat_gold);
+    cv::gpu::GpuMat dev_mat(mat_gold);
 
-        mat_gold.setTo(s);
-        dev_mat.setTo(s);
+    mat_gold.setTo(s);
+    dev_mat.setTo(s);
 
-        dev_mat.download(mat);
-    );
+    dev_mat.download(mat);
 
     EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
 }
@@ -303,14 +293,12 @@ TEST_P(SetTo, DifferentVal)
 
     cv::Mat mat;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
+    cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
 
-        mat_gold.setTo(s);
-        dev_mat.setTo(s);
+    mat_gold.setTo(s);
+    dev_mat.setTo(s);
 
-        dev_mat.download(mat);
-    );
+    dev_mat.download(mat);
 
     EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
 }
@@ -327,14 +315,12 @@ TEST_P(SetTo, Masked)
 
     cv::Mat mat;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
+    cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
 
-        mat_gold.setTo(s, mask);
-        dev_mat.setTo(s, loadMat(mask, useRoi));
+    mat_gold.setTo(s, mask);
+    dev_mat.setTo(s, loadMat(mask, useRoi));
 
-        dev_mat.download(mat);
-    );
+    dev_mat.download(mat);
 
     EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
 }
@@ -382,14 +368,12 @@ TEST_P(CopyTo, WithoutMask)
 
     cv::Mat dst;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dev_dst = loadMat(src, useRoi);
+    cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dev_dst = loadMat(src, useRoi);
 
-        dev_src.copyTo(dev_dst);
+    dev_src.copyTo(dev_dst);
 
-        dev_dst.download(dst);
-    );
+    dev_dst.download(dst);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
@@ -410,14 +394,12 @@ TEST_P(CopyTo, Masked)
 
     cv::Mat dst;
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dev_dst = loadMat(zeroMat, useRoi);
+    cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dev_dst = loadMat(zeroMat, useRoi);
 
-        dev_src.copyTo(dev_dst, loadMat(mask, useRoi));
+    dev_src.copyTo(dev_dst, loadMat(mask, useRoi));
 
-        dev_dst.download(dst);
-    );
+    dev_dst.download(dst);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
@@ -467,14 +449,12 @@ TEST_P(ConvertTo, WithoutScaling)
 
     cv::Mat dst;
     
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dev_dst;
+    cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dev_dst;
 
-        dev_src.convertTo(dev_dst, depth2);
+    dev_src.convertTo(dev_dst, depth2);
 
-        dev_dst.download(dst);
-    );
+    dev_dst.download(dst);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
@@ -494,15 +474,13 @@ TEST_P(ConvertTo, WithScaling)
 
     cv::Mat dst;
     
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
 
-        cv::gpu::GpuMat dev_dst;
+    cv::gpu::GpuMat dev_dst;
 
-        dev_src.convertTo(dev_dst, depth2, a, b);
+    dev_src.convertTo(dev_dst, depth2, a, b);
 
-        dev_dst.download(dst);
-    );
+    dev_dst.download(dst);
 
     const double eps = depth2 < CV_32F ? 1 : 1e-4;
 
@@ -549,30 +527,28 @@ TEST_P(Async, Accuracy)
 {
     cv::Mat dst0, dst1;
     
-    ASSERT_NO_THROW(
-        cv::gpu::CudaMem cpudst0;
-        cv::gpu::CudaMem cpudst1;
+    cv::gpu::CudaMem cpudst0;
+    cv::gpu::CudaMem cpudst1;
 
-        cv::gpu::GpuMat gpusrc;
-        cv::gpu::GpuMat gpudst0;
-        cv::gpu::GpuMat gpudst1(src.rows, src.cols, CV_8UC1);
+    cv::gpu::GpuMat gpusrc;
+    cv::gpu::GpuMat gpudst0;
+    cv::gpu::GpuMat gpudst1(src.rows, src.cols, CV_8UC1);
 
-        cv::gpu::Stream stream0;
-        cv::gpu::Stream stream1;
+    cv::gpu::Stream stream0;
+    cv::gpu::Stream stream1;
 
-        stream0.enqueueUpload(src, gpusrc);
-        cv::gpu::bitwise_not(gpusrc, gpudst0, cv::gpu::GpuMat(), stream0);
-        stream0.enqueueDownload(gpudst0, cpudst0);
+    stream0.enqueueUpload(src, gpusrc);
+    cv::gpu::bitwise_not(gpusrc, gpudst0, cv::gpu::GpuMat(), stream0);
+    stream0.enqueueDownload(gpudst0, cpudst0);
 
-        stream1.enqueueMemSet(gpudst1, cv::Scalar::all(128));
-        stream1.enqueueDownload(gpudst1, cpudst1);
+    stream1.enqueueMemSet(gpudst1, cv::Scalar::all(128));
+    stream1.enqueueDownload(gpudst1, cpudst1);
 
-        stream0.waitForCompletion();
-        stream1.waitForCompletion();
+    stream0.waitForCompletion();
+    stream1.waitForCompletion();
 
-        dst0 = cpudst0.createMatHeader();
-        dst1 = cpudst1.createMatHeader();
-    );
+    dst0 = cpudst0.createMatHeader();
+    dst1 = cpudst1.createMatHeader();
 
     EXPECT_MAT_NEAR(dst_gold0, dst0, 0.0);
     EXPECT_MAT_NEAR(dst_gold1, dst1, 0.0);

modules/gpu/test/test_nvidia.cpp

@@ -88,121 +88,77 @@ OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
 
 TEST_P(NPPST, Integral) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, SquaredIntegral) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, RectStdDev) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Resize) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, VectorOperations) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Transpose) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, VectorOperations) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeLoader) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeApplication) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HypothesesFiltration) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, Visualization) 
 {
-    bool res;
-
-    ASSERT_NO_THROW(
-        res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
-    );
+    bool res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }

modules/gpu/test/test_video.cpp

@@ -117,14 +117,13 @@ TEST_P(BroxOpticalFlow, Regression)
     cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 
                                     10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat d_u; 
-        cv::gpu::GpuMat d_v;
-        d_flow(cv::gpu::GpuMat(frame0), cv::gpu::GpuMat(frame1), d_u, d_v);
-        d_u.download(u);
-        d_v.download(v);
-        d_flow.buf.release();
-    );
+    cv::gpu::GpuMat d_u; 
+    cv::gpu::GpuMat d_v;
+
+    d_flow(cv::gpu::GpuMat(frame0), cv::gpu::GpuMat(frame1), d_u, d_v);
+
+    d_u.download(u);
+    d_v.download(v);
 
 #ifndef DUMP
 
@@ -212,21 +211,23 @@ TEST_P(InterpolateFrames, Regression)
     cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 
                                     10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-    ASSERT_NO_THROW(
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_fu; 
-        cv::gpu::GpuMat d_fv;
-        cv::gpu::GpuMat d_bu; 
-        cv::gpu::GpuMat d_bv;
-        cv::gpu::GpuMat d_newFrame;
-        cv::gpu::GpuMat d_buf;
-        d_flow(d_frame0, d_frame1, d_fu, d_fv);
-        d_flow(d_frame1, d_frame0, d_bu, d_bv);
-        cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-        d_newFrame.download(newFrame);
-        d_flow.buf.release();
-    );
+    cv::gpu::GpuMat d_frame0(frame0);
+    cv::gpu::GpuMat d_frame1(frame1);
+
+    cv::gpu::GpuMat d_fu; 
+    cv::gpu::GpuMat d_fv;
+    cv::gpu::GpuMat d_bu; 
+    cv::gpu::GpuMat d_bv;
+
+    d_flow(d_frame0, d_frame1, d_fu, d_fv);
+    d_flow(d_frame1, d_frame0, d_bu, d_bv);
+
+    cv::gpu::GpuMat d_newFrame;
+    cv::gpu::GpuMat d_buf;
+
+    cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
+
+    d_newFrame.download(newFrame);
 
 #ifndef DUMP