From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 19 Dec 2012 07:13:31 +0000 (+0400)
Subject: Revert "call resetDevice if gpu test fails"
X-Git-Tag: submit/tizen_ivi/20141117.190038~2^2~1214^2~10
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=4ba33fa1ed05451d93027bf497ac15d23cf0aa29;p=profile%2Fivi%2Fopencv.git

Revert "call resetDevice if gpu test fails"

This reverts commit ab25fe9e377fdbd69c916d5124483fa26e4a7835.
---

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
index 96a5151..928b30a 100644
--- a/modules/gpu/app/nv_perf_test/main.cpp
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -92,23 +92,15 @@ PERF_TEST_P(Image, HoughLinesP,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
-            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-            }
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
         }
     }
     else
@@ -163,25 +155,17 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
+        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
 
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_pts;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_pts;
 
-            d_detector(d_src, d_pts, d_mask);
+        d_detector(d_src, d_pts, d_mask);
 
-            TEST_CYCLE()
-            {
-                d_detector(d_src, d_pts, d_mask);
-            }
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_detector(d_src, d_pts, d_mask);
         }
     }
     else
@@ -260,31 +244,23 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
-            cv::gpu::GpuMat d_nextPts;
-            cv::gpu::GpuMat d_status;
-
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = winSize;
-            d_pyrLK.maxLevel = maxLevel;
-            d_pyrLK.iters = criteria.maxCount;
-            d_pyrLK.useInitialFlow = false;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
 
-            d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = winSize;
+        d_pyrLK.maxLevel = maxLevel;
+        d_pyrLK.iters = criteria.maxCount;
+        d_pyrLK.useInitialFlow = false;
 
-            TEST_CYCLE()
-            {
-                d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
-            }
-        }
-        catch (...)
+        d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
         }
     }
     else
@@ -346,33 +322,25 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
-            cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
-
-            cv::gpu::FarnebackOpticalFlow d_farneback;
-            d_farneback.pyrScale = pyrScale;
-            d_farneback.numLevels = numLevels;
-            d_farneback.winSize = winSize;
-            d_farneback.numIters = numIters;
-            d_farneback.polyN = polyN;
-            d_farneback.polySigma = polySigma;
-            d_farneback.flags = flags;
-
-            d_farneback(d_src1, d_src2, d_u, d_v);
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
+        cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
+
+        cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.numLevels = numLevels;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
+
+        d_farneback(d_src1, d_src2, d_u, d_v);
 
-            TEST_CYCLE_N(10)
-            {
-                d_farneback(d_src1, d_src2, d_u, d_v);
-            }
-        }
-        catch (...)
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_farneback(d_src1, d_src2, d_u, d_v);
         }
     }
     else
@@ -441,23 +409,15 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_velx, d_vely, buf;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
 
-            cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+        cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
 
-            TEST_CYCLE_N(10)
-            {
-                cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-            }
-        }
-        catch (...)
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
         }
     }
     else
@@ -500,25 +460,17 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_velx, d_vely;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely;
 
-            cv::gpu::FastOpticalFlowBM fastBM;
+        cv::gpu::FastOpticalFlowBM fastBM;
 
-            fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+        fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
 
-            TEST_CYCLE_N(10)
-            {
-                fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
-            }
-        }
-        catch (...)
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::resetDevice();
-            throw;
+            fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
         }
     }
     else
diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
index 3a086d9..906024f 100644
--- a/modules/gpu/perf/perf_calib3d.cpp
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -26,28 +26,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png",
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
-
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
 
-            d_bm(d_imgLeft, d_imgRight, d_dst);
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                d_bm(d_imgLeft, d_imgRight, d_dst);
-            }
+        d_bm(d_imgLeft, d_imgRight, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_bm(d_imgLeft, d_imgRight, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -83,28 +75,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::StereoBeliefPropagation d_bp(ndisp);
+        cv::gpu::StereoBeliefPropagation d_bp(ndisp);
 
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
 
-            d_bp(d_imgLeft, d_imgRight, d_dst);
-
-            TEST_CYCLE()
-            {
-                d_bp(d_imgLeft, d_imgRight, d_dst);
-            }
+        d_bp(d_imgLeft, d_imgRight, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_bp(d_imgLeft, d_imgRight, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -129,28 +113,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
+        cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
 
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
 
-            d_csbp(d_imgLeft, d_imgRight, d_dst);
+        d_csbp(d_imgLeft, d_imgRight, d_dst);
 
-            TEST_CYCLE()
-            {
-                d_csbp(d_imgLeft, d_imgRight, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_csbp(d_imgLeft, d_imgRight, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -173,28 +149,20 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::DisparityBilateralFilter d_filter(ndisp);
+        cv::gpu::DisparityBilateralFilter d_filter(ndisp);
 
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_disp(disp);
-            cv::gpu::GpuMat d_dst;
-
-            d_filter(d_disp, d_img, d_dst);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_disp(disp);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                d_filter(d_disp, d_img, d_dst);
-            }
+        d_filter(d_disp, d_img, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_filter(d_disp, d_img, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -219,25 +187,17 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
-            }
+        cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -261,25 +221,17 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
-            }
+        cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -331,19 +283,11 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+        cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-            }
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
         }
     }
     else
@@ -376,25 +320,17 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
-            }
+        cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -424,25 +360,17 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::drawColorDisp(d_src, d_dst, 255);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::drawColorDisp(d_src, d_dst, 255);
-            }
+        cv::gpu::drawColorDisp(d_src, d_dst, 255);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::drawColorDisp(d_src, d_dst, 255);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index 92d87c2..ad722fa 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -22,23 +22,15 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            std::vector<cv::gpu::GpuMat> d_src(channels);
-            for (int i = 0; i < channels; ++i)
-                d_src[i].upload(src[i]);
+        std::vector<cv::gpu::GpuMat> d_src(channels);
+        for (int i = 0; i < channels; ++i)
+            d_src[i].upload(src[i]);
 
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-12);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-12);
     }
     else
     {
@@ -63,22 +55,14 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_src(src);
 
-            std::vector<cv::gpu::GpuMat> d_dst;
+        std::vector<cv::gpu::GpuMat> d_dst;
 
-            TEST_CYCLE() cv::gpu::split(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::split(d_src, d_dst);
 
-            cv::gpu::GpuMat first = d_dst[0];
-            GPU_SANITY_CHECK(first, 1e-12);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        cv::gpu::GpuMat first = d_dst[0];
+        GPU_SANITY_CHECK(first, 1e-12);
     }
     else
     {
@@ -106,21 +90,13 @@ PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEP
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -147,20 +123,12 @@ PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -188,21 +156,13 @@ PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -229,20 +189,12 @@ PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -270,21 +222,13 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -311,22 +255,14 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::multiply(d_src, s, d_dst);
+        cv::gpu::multiply(d_src, s, d_dst);
 
-            TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -354,21 +290,13 @@ PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -395,20 +323,12 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_M
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -435,20 +355,12 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
+        TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -476,21 +388,13 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -517,20 +421,12 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -555,20 +451,12 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else FAIL_NO_CPU();
 }
@@ -586,20 +474,12 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else FAIL_NO_CPU();
 }
@@ -617,20 +497,12 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -655,20 +527,12 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::log(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::log(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -693,20 +557,12 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -734,20 +590,12 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
+        TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -781,21 +629,13 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
+        TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -823,20 +663,12 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
+        TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -861,20 +693,12 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -902,21 +726,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -944,20 +760,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -985,21 +793,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1029,20 +829,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1070,21 +862,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1112,20 +896,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1155,20 +931,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1194,20 +962,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1231,21 +991,13 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1272,20 +1024,12 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1313,21 +1057,13 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1354,20 +1090,12 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1403,21 +1131,13 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
+        TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1432,8 +1152,6 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 //////////////////////////////////////////////////////////////////////
 // GEMM
 
-#ifdef HAVE_CUBLAS
-
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
 #define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T)
 
@@ -1461,22 +1179,14 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_src3(src3);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_src3(src3);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
+        TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1490,8 +1200,6 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
     }
 }
 
-#endif // HAVE_CUBLAS
-
 //////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -1507,20 +1215,12 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1559,20 +1259,12 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
+        TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1602,20 +1294,12 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1645,20 +1329,12 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1682,20 +1358,12 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1722,20 +1390,12 @@ PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1758,21 +1418,13 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1781,6 +1433,7 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
         TEST_CYCLE() cv::magnitude(src1, src2, dst);
 
         CPU_SANITY_CHECK(dst, 1e-8);
+
     }
 }
 
@@ -1799,21 +1452,13 @@ PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1839,21 +1484,13 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
+        TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1881,23 +1518,16 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_magnitude;
-            cv::gpu::GpuMat d_angle;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_magnitude;
+        cv::gpu::GpuMat d_angle;
 
-            TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+        TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+
+        GPU_SANITY_CHECK(d_magnitude, 1e-8);
+        GPU_SANITY_CHECK(d_angle, 1e-8);
 
-            GPU_SANITY_CHECK(d_magnitude, 1e-8);
-            GPU_SANITY_CHECK(d_angle, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
     }
     else
     {
@@ -1927,23 +1557,15 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_magnitude(magnitude);
-            cv::gpu::GpuMat d_angle(angle);
-            cv::gpu::GpuMat d_x;
-            cv::gpu::GpuMat d_y;
+        cv::gpu::GpuMat d_magnitude(magnitude);
+        cv::gpu::GpuMat d_angle(angle);
+        cv::gpu::GpuMat d_x;
+        cv::gpu::GpuMat d_y;
 
-            TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
+        TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
 
-            GPU_SANITY_CHECK(d_x, 1e-8);
-            GPU_SANITY_CHECK(d_y, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_x, 1e-8);
+        GPU_SANITY_CHECK(d_y, 1e-8);
     }
     else
     {
@@ -1972,18 +1594,10 @@ PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
     }
     else
     {
@@ -2014,18 +1628,10 @@ PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
     }
     else
     {
@@ -2057,18 +1663,11 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+
+        TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
 
-            TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
     }
     else
     {
@@ -2099,18 +1698,10 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
     }
     else
     {
@@ -2141,20 +1732,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
 
-            SANITY_CHECK(dst, 1e-6);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
@@ -2183,20 +1766,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
 
-            SANITY_CHECK(dst, 1e-6);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
@@ -2221,21 +1796,13 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
+        TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
 
-            SANITY_CHECK(minVal);
-            SANITY_CHECK(maxVal);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(minVal);
+        SANITY_CHECK(maxVal);
     }
     else
     {
@@ -2261,18 +1828,10 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_valbuf, d_locbuf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_valbuf, d_locbuf;
 
-            TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
     }
     else
     {
@@ -2304,18 +1863,10 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
     }
     else
     {
@@ -2357,20 +1908,12 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
+        TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
 
-            GPU_SANITY_CHECK(d_dst, 1);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_denoising.cpp b/modules/gpu/perf/perf_denoising.cpp
index 0be16cb..ed63177 100644
--- a/modules/gpu/perf/perf_denoising.cpp
+++ b/modules/gpu/perf/perf_denoising.cpp
@@ -30,27 +30,19 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
     cv::Mat src(size, type);
     fillRandom(src);
 
-    if (PERF_RUN_GPU())
+     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
-            }
+        cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -95,25 +87,17 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
-            }
+        cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -146,26 +130,18 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::FastNonLocalMeansDenoising fnlmd;
-
-            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-            TEST_CYCLE()
-            {
-                fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
-            }
+        fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -205,26 +181,18 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::FastNonLocalMeansDenoising fnlmd;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-
-            TEST_CYCLE()
-            {
-                fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-            }
+        fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -238,4 +206,4 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
         CPU_SANITY_CHECK(dst);
     }
-}
+}
\ No newline at end of file
diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp
index a0ecf04..a93cef9 100644
--- a/modules/gpu/perf/perf_features2d.cpp
+++ b/modules/gpu/perf/perf_features2d.cpp
@@ -19,28 +19,20 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::SURF_GPU d_surf;
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints, d_descriptors;
+        cv::gpu::SURF_GPU d_surf;
 
-            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-            TEST_CYCLE()
-            {
-                d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-            }
+        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-            GPU_SANITY_CHECK(d_descriptors, 1e-4);
-            GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
         }
+
+        GPU_SANITY_CHECK(d_descriptors, 1e-4);
+        GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
     }
     else
     {
@@ -72,27 +64,19 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::FAST_GPU d_fast(20);
+        cv::gpu::FAST_GPU d_fast(20);
 
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints;
 
-            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
 
-            TEST_CYCLE()
-            {
-                d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
-            }
-
-            GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
         }
+
+        GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
     }
     else
     {
@@ -120,28 +104,20 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::ORB_GPU d_orb(4000);
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints, d_descriptors;
+        cv::gpu::ORB_GPU d_orb(4000);
 
-            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-            TEST_CYCLE()
-            {
-                d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-            }
+        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-            GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
-            GPU_SANITY_CHECK(d_descriptors);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
         }
+
+        GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
+        GPU_SANITY_CHECK(d_descriptors);
     }
     else
     {
@@ -185,29 +161,21 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_distance;
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance;
 
-            TEST_CYCLE()
-            {
-                d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
-            }
+        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
@@ -252,29 +220,21 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
 
-            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
 
-            TEST_CYCLE()
-            {
-                d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
-            }
-
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
@@ -313,29 +273,21 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
 
-            TEST_CYCLE()
-            {
-                d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
-            }
+        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
 
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 47265fe..7faf93e 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -23,25 +23,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
-            }
+        cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -74,26 +66,18 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-            }
+        cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -125,26 +109,18 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
-
-            cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
-            }
+        cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -177,26 +153,18 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
-
-            cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
-            }
+        cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -229,25 +197,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
-            }
+        cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -281,26 +241,18 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::erode(d_src, d_dst, ker, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::erode(d_src, d_dst, ker, d_buf);
-            }
+        cv::gpu::erode(d_src, d_dst, ker, d_buf);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::erode(d_src, d_dst, ker, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -334,26 +286,18 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
-
-            cv::gpu::dilate(d_src, d_dst, ker, d_buf);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::dilate(d_src, d_dst, ker, d_buf);
-            }
+        cv::gpu::dilate(d_src, d_dst, ker, d_buf);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::dilate(d_src, d_dst, ker, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -393,27 +337,19 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf1;
-            cv::gpu::GpuMat d_buf2;
-
-            cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf1;
+        cv::gpu::GpuMat d_buf2;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
-            }
+        cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -449,25 +385,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::filter2D(d_src, d_dst, -1, kernel);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::filter2D(d_src, d_dst, -1, kernel);
-            }
+        cv::gpu::filter2D(d_src, d_dst, -1, kernel);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::filter2D(d_src, d_dst, -1, kernel);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 545b8df..ee09684 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -80,27 +80,19 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_xmap(xmap);
-            cv::gpu::GpuMat d_ymap(ymap);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_xmap(xmap);
+        cv::gpu::GpuMat d_ymap(ymap);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
-            }
+        cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -142,25 +134,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-            }
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -201,25 +185,17 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-            }
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -266,25 +242,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-            }
+        cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -330,25 +298,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-            }
+        cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -386,25 +346,17 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
-            }
+        cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -441,25 +393,17 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-            }
+        cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -486,26 +430,18 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-            }
+        cv::gpu::integralBuffered(d_src, d_dst, d_buf);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::integralBuffered(d_src, d_dst, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -532,25 +468,17 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::sqrIntegral(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::sqrIntegral(d_src, d_dst);
-            }
+        cv::gpu::sqrIntegral(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::sqrIntegral(d_src, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -571,26 +499,18 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-            }
+        cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
 
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -628,26 +548,18 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist[4];
-            cv::gpu::GpuMat d_buf, d_hist0;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist[4];
+        cv::gpu::GpuMat d_buf, d_hist0;
 
-            cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-            }
+        cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
 
-            GPU_SANITY_CHECK(d_hist0);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
         }
+
+        GPU_SANITY_CHECK(d_hist0);
     }
     else
     {
@@ -667,25 +579,17 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist;
 
-            cv::gpu::calcHist(d_src, d_hist);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::calcHist(d_src, d_hist);
-            }
+        cv::gpu::calcHist(d_src, d_hist);
 
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::calcHist(d_src, d_hist);
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -705,27 +609,19 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_hist;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-            }
+        cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
 
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -752,25 +648,17 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::columnSum(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::columnSum(d_src, d_dst);
-            }
+        cv::gpu::columnSum(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::columnSum(d_src, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -797,26 +685,18 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::CannyBuf d_buf;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::CannyBuf d_buf;
 
-            cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
+        cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -848,25 +728,17 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-            }
+        cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -896,26 +768,18 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
-            cv::gpu::GpuMat d_dstr;
-            cv::gpu::GpuMat d_dstsp;
+        cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_dstr;
+        cv::gpu::GpuMat d_dstsp;
 
-            cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-            }
+        cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
 
-            GPU_SANITY_CHECK(d_dstr);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
         }
+
+        GPU_SANITY_CHECK(d_dstr);
     }
     else
     {
@@ -940,24 +804,16 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_src(rgba);
 
-            cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-            }
+        cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
 
-            GPU_SANITY_CHECK(dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
         }
+
+        GPU_SANITY_CHECK(dst);
     }
     else
     {
@@ -984,28 +840,20 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img1(img1);
-            cv::gpu::GpuMat d_img2(img2);
-            cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
-            cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_img1(img1);
+        cv::gpu::GpuMat d_img2(img2);
+        cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
+        cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-            }
+        cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1034,31 +882,23 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
-            d_image.upload(image);
+        cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+        d_image.upload(image);
 
-            cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
-            d_templ.upload(templ);
+        cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+        d_templ.upload(templ);
 
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::ConvolveBuf d_buf;
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::ConvolveBuf d_buf;
 
-            cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-            }
+        cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1104,26 +944,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_templ(templ);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_templ(templ);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-            }
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1162,26 +994,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_templ(templ);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_templ(templ);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1220,26 +1044,18 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_a(a);
-            cv::gpu::GpuMat d_b(b);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_a(a);
+        cv::gpu::GpuMat d_b(b);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-            }
+        cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1273,26 +1089,18 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-            }
+        cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1317,25 +1125,17 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::dft(d_src, d_dst, size, flag);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::dft(d_src, d_dst, size, flag);
-            }
+        cv::gpu::dft(d_src, d_dst, size, flag);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::dft(d_src, d_dst, size, flag);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1378,28 +1178,20 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_Dx;
-            cv::gpu::GpuMat d_Dy;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_Dx;
+        cv::gpu::GpuMat d_Dy;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-            }
+        cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1439,28 +1231,20 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_Dx;
-            cv::gpu::GpuMat d_Dy;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_Dx;
+        cv::gpu::GpuMat d_Dy;
+        cv::gpu::GpuMat d_buf;
 
-            cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-            }
+        cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1490,26 +1274,18 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
-            cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-            }
+        cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
 
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
     }
     else
     {
@@ -1529,26 +1305,18 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
-            cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-            }
+        cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
 
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
     }
     else
     {
@@ -1568,26 +1336,19 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
-
-            cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-            }
+        cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
 
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
+
     }
     else
     {
@@ -1618,25 +1379,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
+        cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1663,25 +1416,17 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::pyrDown(d_src, d_dst);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::pyrDown(d_src, d_dst);
-            }
+        cv::gpu::pyrDown(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::pyrDown(d_src, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1717,25 +1462,17 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::pyrUp(d_src, d_dst);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::pyrUp(d_src, d_dst);
-            }
+        cv::gpu::pyrUp(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::pyrUp(d_src, d_dst);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1796,25 +1533,17 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
-            }
+        cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1845,24 +1574,16 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_src(src);
 
-            cv::gpu::swapChannels(d_src, dstOrder);
+        cv::gpu::swapChannels(d_src, dstOrder);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::swapChannels(d_src, dstOrder);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::swapChannels(d_src, dstOrder);
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -1892,26 +1613,18 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img1(img1);
-            cv::gpu::GpuMat d_img2(img2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_img1(img1);
+        cv::gpu::GpuMat d_img2(img2);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
+        cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1935,26 +1648,18 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_src(src);
 
-            cv::gpu::ImagePyramid d_pyr;
+        cv::gpu::ImagePyramid d_pyr;
 
-            d_pyr.build(d_src, 5);
+        d_pyr.build(d_src, 5);
 
-            TEST_CYCLE()
-            {
-                d_pyr.build(d_src, 5);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_pyr.build(d_src, 5);
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -1980,27 +1685,19 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::ImagePyramid d_pyr(d_src, 3);
+        cv::gpu::ImagePyramid d_pyr(d_src, 3);
 
-            d_pyr.getLayer(d_dst, dstSize);
+        d_pyr.getLayer(d_dst, dstSize);
 
-            TEST_CYCLE()
-            {
-                d_pyr.getLayer(d_dst, dstSize);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_pyr.getLayer(d_dst, dstSize);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -2065,30 +1762,22 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
-            cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
+        cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
-            }
-
-            cv::Mat h_lines(d_lines);
-            cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
-            cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
-            std::sort(begin, end, Vec2fComparator());
-            SANITY_CHECK(h_lines);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
         }
+
+        cv::Mat h_lines(d_lines);
+        cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
+        cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
+        std::sort(begin, end, Vec2fComparator());
+        SANITY_CHECK(h_lines);
     }
     else
     {
@@ -2129,30 +1818,22 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
-
-            cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-            }
+        cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
 
-            cv::Mat h_lines(d_lines);
-            cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
-            cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
-            std::sort(begin, end, Vec4iComparator());
-            SANITY_CHECK(h_lines);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
         }
+
+        cv::Mat h_lines(d_lines);
+        cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
+        cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
+        std::sort(begin, end, Vec4iComparator());
+        SANITY_CHECK(h_lines);
     }
     else
     {
@@ -2202,30 +1883,22 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_circles;
-            cv::gpu::HoughCirclesBuf d_buf;
-
-            cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_circles;
+        cv::gpu::HoughCirclesBuf d_buf;
 
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-            }
+        cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
 
-            cv::Mat h_circles(d_circles);
-            cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
-            cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
-            std::sort(begin, end, Vec3fComparator());
-            SANITY_CHECK(h_circles);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
         }
+
+        cv::Mat h_circles(d_circles);
+        cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
+        cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
+        std::sort(begin, end, Vec3fComparator());
+        SANITY_CHECK(h_circles);
     }
     else
     {
@@ -2294,36 +1967,28 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_edges(edges);
-            cv::gpu::GpuMat d_dx(dx);
-            cv::gpu::GpuMat d_dy(dy);
-            cv::gpu::GpuMat d_position;
+        cv::gpu::GpuMat d_edges(edges);
+        cv::gpu::GpuMat d_dx(dx);
+        cv::gpu::GpuMat d_dy(dy);
+        cv::gpu::GpuMat d_position;
 
-            cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
-            if (method & cv::GHT_ROTATION)
-            {
-                d_hough->set("maxAngle", 90.0);
-                d_hough->set("angleStep", 2.0);
-            }
-
-            d_hough->setTemplate(cv::gpu::GpuMat(templ));
+        cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
+        if (method & cv::GHT_ROTATION)
+        {
+            d_hough->set("maxAngle", 90.0);
+            d_hough->set("angleStep", 2.0);
+        }
 
-            d_hough->detect(d_edges, d_dx, d_dy, d_position);
+        d_hough->setTemplate(cv::gpu::GpuMat(templ));
 
-            TEST_CYCLE()
-            {
-                d_hough->detect(d_edges, d_dx, d_dy, d_position);
-            }
+        d_hough->detect(d_edges, d_dx, d_dy, d_position);
 
-            GPU_SANITY_CHECK(d_position);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_hough->detect(d_edges, d_dx, d_dy, d_position);
         }
+
+        GPU_SANITY_CHECK(d_position);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_labeling.cpp b/modules/gpu/perf/perf_labeling.cpp
index 0fb81aa..3b10ba3 100644
--- a/modules/gpu/perf/perf_labeling.cpp
+++ b/modules/gpu/perf/perf_labeling.cpp
@@ -108,30 +108,22 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat mask;
-            mask.create(image.rows, image.cols, CV_8UC1);
-
-            cv::gpu::GpuMat components;
-            components.create(image.rows, image.cols, CV_32SC1);
+        cv::gpu::GpuMat mask;
+        mask.create(image.rows, image.cols, CV_8UC1);
 
-            cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+        cv::gpu::GpuMat components;
+        components.create(image.rows, image.cols, CV_32SC1);
 
-            ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
 
-            TEST_CYCLE()
-            {
-                cv::gpu::labelComponents(mask, components);
-            }
+        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
 
-            GPU_SANITY_CHECK(components);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::labelComponents(mask, components);
         }
+
+        GPU_SANITY_CHECK(components);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp
index 97f6dd1d..b6d4a11 100644
--- a/modules/gpu/perf/perf_matop.cpp
+++ b/modules/gpu/perf/perf_matop.cpp
@@ -20,24 +20,16 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(size, type);
-
-            d_src.setTo(val);
+        cv::gpu::GpuMat d_src(size, type);
 
-            TEST_CYCLE()
-            {
-                d_src.setTo(val);
-            }
+        d_src.setTo(val);
 
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_src.setTo(val);
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -75,25 +67,17 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
-
-            d_src.setTo(val, d_mask);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
 
-            TEST_CYCLE()
-            {
-                d_src.setTo(val, d_mask);
-            }
+        d_src.setTo(val, d_mask);
 
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_src.setTo(val, d_mask);
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -127,26 +111,18 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_dst;
-
-            d_src.copyTo(d_dst, d_mask);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                d_src.copyTo(d_dst, d_mask);
-            }
+        d_src.copyTo(d_dst, d_mask);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_src.copyTo(d_dst, d_mask);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -179,25 +155,17 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE()
-            {
-                d_src.convertTo(d_dst, depth2, 0.5, 1.0);
-            }
+        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_src.convertTo(d_dst, depth2, 0.5, 1.0);
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 4c74bba..6d040ac 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -19,24 +19,16 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_img(img);
 
-            cv::gpu::HOGDescriptor d_hog;
-            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
 
-            d_hog.detectMultiScale(d_img, found_locations);
+        d_hog.detectMultiScale(d_img, found_locations);
 
-            TEST_CYCLE()
-            {
-                d_hog.detectMultiScale(d_img, found_locations);
-            }
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_hog.detectMultiScale(d_img, found_locations);
         }
     }
     else
@@ -69,24 +61,16 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_img(img);
 
-            cv::gpu::HOGDescriptor d_hog;
-            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
 
-            d_hog.detectMultiScale(d_img, found_locations);
+        d_hog.detectMultiScale(d_img, found_locations);
 
-            TEST_CYCLE()
-            {
-                d_hog.detectMultiScale(d_img, found_locations);
-            }
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_hog.detectMultiScale(d_img, found_locations);
         }
     }
     else
@@ -119,28 +103,20 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::CascadeClassifier_GPU d_cascade;
-            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_objects_buffer;
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-            d_cascade.detectMultiScale(d_img, d_objects_buffer);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_objects_buffer;
 
-            TEST_CYCLE()
-            {
-                d_cascade.detectMultiScale(d_img, d_objects_buffer);
-            }
+        d_cascade.detectMultiScale(d_img, d_objects_buffer);
 
-            GPU_SANITY_CHECK(d_objects_buffer);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_cascade.detectMultiScale(d_img, d_objects_buffer);
         }
+
+        GPU_SANITY_CHECK(d_objects_buffer);
     }
     else
     {
@@ -171,28 +147,20 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::CascadeClassifier_GPU d_cascade;
-            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_gpu_rects;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_gpu_rects;
 
-            d_cascade.detectMultiScale(d_img, d_gpu_rects);
-
-            TEST_CYCLE()
-            {
-                d_cascade.detectMultiScale(d_img, d_gpu_rects);
-            }
+        d_cascade.detectMultiScale(d_img, d_gpu_rects);
 
-            GPU_SANITY_CHECK(d_gpu_rects);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_cascade.detectMultiScale(d_img, d_gpu_rects);
         }
+
+        GPU_SANITY_CHECK(d_gpu_rects);
     }
     else
     {
@@ -212,4 +180,4 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     }
 }
 
-} // namespace
+} // namespace
\ No newline at end of file
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 1d3ebe8..9645bee 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -60,36 +60,28 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
 
 RUN_GPU(SCascadeTest, detect)
 {
-    try
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
 
-        cv::gpu::SCascade cascade;
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(1);
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(1);
 
-        cascade.detect(colored, rois, objectBoxes);
+    cascade.detect(colored, rois, objectBoxes);
 
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
+    TEST_CYCLE()
     {
-        cv::gpu::resetDevice();
-        throw;
+        cascade.detect(colored, rois, objectBoxes);
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detect)
@@ -126,45 +118,37 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
 
 RUN_GPU(SCascadeTestRoi, detectInRoi)
 {
-    try
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
 
-        cv::gpu::SCascade cascade;
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
 
-        int nroi = GET_PARAM(2);
-        cv::RNG rng;
-        for (int i = 0; i < nroi; ++i)
-        {
-            cv::Rect r = getFromTable(rng(10));
-            cv::gpu::GpuMat sub(rois, r);
-            sub.setTo(1);
-        }
-
-        cascade.detect(colored, rois, objectBoxes);
+    int nroi = GET_PARAM(2);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
+    {
+        cv::Rect r = getFromTable(rng(10));
+        cv::gpu::GpuMat sub(rois, r);
+        sub.setTo(1);
+    }
 
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
+    cascade.detect(colored, rois, objectBoxes);
 
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
+    TEST_CYCLE()
     {
-        cv::gpu::resetDevice();
-        throw;
+        cascade.detect(colored, rois, objectBoxes);
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTestRoi, detectInRoi)
@@ -179,41 +163,33 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
 
 RUN_GPU(SCascadeTestRoi, detectEachRoi)
 {
-    try
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SCascade cascade;
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::gpu::SCascade cascade;
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        int idx = GET_PARAM(2);
-        cv::Rect r = getFromTable(idx);
-        cv::gpu::GpuMat sub(rois, r);
-        sub.setTo(1);
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
 
-        cascade.detect(colored, rois, objectBoxes);
+    int idx = GET_PARAM(2);
+    cv::Rect r = getFromTable(idx);
+    cv::gpu::GpuMat sub(rois, r);
+    sub.setTo(1);
 
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
+    cascade.detect(colored, rois, objectBoxes);
 
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
+    TEST_CYCLE()
     {
-        cv::gpu::resetDevice();
-        throw;
+        cascade.detect(colored, rois, objectBoxes);
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTestRoi, detectEachRoi)
@@ -233,44 +209,36 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
 
 RUN_GPU(SCascadeTest, detectOnIntegral)
 {
-    try
-    {
-        cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-        ASSERT_TRUE(fsi.isOpened());
-
-        cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
-        for (int i = 0; i < 10; ++i)
-        {
-            cv::Mat channel;
-            fsi[std::string("channel") + itoa(i)] >> channel;
-            cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-            gchannel.upload(channel);
-        }
+    cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
 
-        cv::gpu::SCascade cascade;
+    cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
+    {
+        cv::Mat channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
+        cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::gpu::SCascade cascade;
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-        rois.setTo(1);
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cascade.detect(hogluv, rois, objectBoxes);
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+    rois.setTo(1);
 
-        TEST_CYCLE()
-        {
-            cascade.detect(hogluv, rois, objectBoxes);
-        }
+    cascade.detect(hogluv, rois, objectBoxes);
 
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
+    TEST_CYCLE()
     {
-        cv::gpu::resetDevice();
-        throw;
+        cascade.detect(hogluv, rois, objectBoxes);
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detectOnIntegral)
@@ -283,42 +251,34 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
 
 RUN_GPU(SCascadeTest, detectStream)
 {
-    try
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
 
-        cv::gpu::SCascade cascade;
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(1);
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(1);
 
-        cv::gpu::Stream s;
+    cv::gpu::Stream s;
 
-        cascade.detect(colored, rois, objectBoxes, s);
+    cascade.detect(colored, rois, objectBoxes, s);
 
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes, s);
-        }
-
-    #ifdef HAVE_CUDA
-        cudaDeviceSynchronize();
-    #endif
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
+    TEST_CYCLE()
     {
-        cv::gpu::resetDevice();
-        throw;
+        cascade.detect(colored, rois, objectBoxes, s);
     }
+
+#ifdef HAVE_CUDA
+    cudaDeviceSynchronize();
+#endif
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detectStream)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 661050e..5afe0d1 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -36,31 +36,23 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
 
-            d_flow(d_frame0, d_frame1, d_u, d_v);
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-            TEST_CYCLE()
-            {
-                d_flow(d_frame0, d_frame1, d_u, d_v);
-            }
+        d_flow(d_frame0, d_frame1, d_u, d_v);
 
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_flow(d_frame0, d_frame1, d_u, d_v);
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -85,39 +77,31 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_fu, d_fv;
-            cv::gpu::GpuMat d_bu, d_bv;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_fu, d_fv;
+        cv::gpu::GpuMat d_bu, d_bv;
 
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-            d_flow(d_frame0, d_frame1, d_fu, d_fv);
-            d_flow(d_frame1, d_frame0, d_bu, 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::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);
+        cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_fu);
-            GPU_SANITY_CHECK(d_fv);
-            GPU_SANITY_CHECK(d_bu);
-            GPU_SANITY_CHECK(d_bv);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
         }
+
+        GPU_SANITY_CHECK(d_fu);
+        GPU_SANITY_CHECK(d_fv);
+        GPU_SANITY_CHECK(d_bu);
+        GPU_SANITY_CHECK(d_bv);
     }
     else
     {
@@ -142,35 +126,27 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
 
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-            d_flow(d_frame0, d_frame1, d_u, d_v);
+        d_flow(d_frame0, d_frame1, d_u, d_v);
 
-            cv::gpu::GpuMat d_vertex, d_colors;
+        cv::gpu::GpuMat d_vertex, d_colors;
 
-            cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
+        cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
 
-            TEST_CYCLE()
-            {
-                cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-            }
-
-            GPU_SANITY_CHECK(d_vertex);
-            GPU_SANITY_CHECK(d_colors);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
         }
+
+        GPU_SANITY_CHECK(d_vertex);
+        GPU_SANITY_CHECK(d_colors);
     }
     else
     {
@@ -194,27 +170,19 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
-
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_pts;
+        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
 
-            d_detector(d_image, d_pts);
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_pts;
 
-            TEST_CYCLE()
-            {
-                d_detector(d_image, d_pts);
-            }
+        d_detector(d_image, d_pts);
 
-            GPU_SANITY_CHECK(d_pts);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_detector(d_image, d_pts);
         }
+
+        GPU_SANITY_CHECK(d_pts);
     }
     else
     {
@@ -270,34 +238,26 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
 
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = cv::Size(winSize, winSize);
-            d_pyrLK.maxLevel = levels - 1;
-            d_pyrLK.iters = iters;
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = cv::Size(winSize, winSize);
+        d_pyrLK.maxLevel = levels - 1;
+        d_pyrLK.iters = iters;
 
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_nextPts;
-            cv::gpu::GpuMat d_status;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
 
-            d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-
-            TEST_CYCLE()
-            {
-                d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-            }
+        d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
 
-            GPU_SANITY_CHECK(d_status);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
         }
+
+        GPU_SANITY_CHECK(d_status);
     }
     else
     {
@@ -345,33 +305,25 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
 
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = cv::Size(winSize, winSize);
-            d_pyrLK.maxLevel = levels - 1;
-            d_pyrLK.iters = iters;
-
-            d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = cv::Size(winSize, winSize);
+        d_pyrLK.maxLevel = levels - 1;
+        d_pyrLK.iters = iters;
 
-            TEST_CYCLE()
-            {
-                d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
-            }
+        d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
 
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -403,37 +355,29 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::FarnebackOpticalFlow d_farneback;
-            d_farneback.numLevels = numLevels;
-            d_farneback.pyrScale = pyrScale;
-            d_farneback.winSize = winSize;
-            d_farneback.numIters = numIters;
-            d_farneback.polyN = polyN;
-            d_farneback.polySigma = polySigma;
-            d_farneback.flags = flags;
-
-            d_farneback(d_frame0, d_frame1, d_u, d_v);
-
-            TEST_CYCLE()
-            {
-                d_farneback(d_frame0, d_frame1, d_u, d_v);
-            }
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
+
+        cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.numLevels = numLevels;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
+
+        d_farneback(d_frame0, d_frame1, d_u, d_v);
 
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_farneback(d_frame0, d_frame1, d_u, d_v);
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -466,30 +410,22 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_flowx;
-            cv::gpu::GpuMat d_flowy;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_flowx;
+        cv::gpu::GpuMat d_flowy;
 
-            cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
 
-            d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+        d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
 
-            TEST_CYCLE()
-            {
-                d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
-            }
-
-            GPU_SANITY_CHECK(d_flowx);
-            GPU_SANITY_CHECK(d_flowy);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
         }
+
+        GPU_SANITY_CHECK(d_flowx);
+        GPU_SANITY_CHECK(d_flowy);
     }
     else
     {
@@ -546,27 +482,19 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_velx, d_vely, buf;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
 
-            cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-            }
+        cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
 
-            GPU_SANITY_CHECK(d_velx);
-            GPU_SANITY_CHECK(d_vely);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
         }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
     }
     else
     {
@@ -601,29 +529,21 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_velx, d_vely;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely;
 
-            cv::gpu::FastOpticalFlowBM fastBM;
+        cv::gpu::FastOpticalFlowBM fastBM;
 
-            fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+        fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
 
-            TEST_CYCLE()
-            {
-                fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
-            }
-
-            GPU_SANITY_CHECK(d_velx);
-            GPU_SANITY_CHECK(d_vely);
-        }
-        catch (...)
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
         }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
     }
     else
     {
@@ -661,29 +581,21 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi",
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::GpuMat d_frame(frame);
 
-            cv::gpu::FGDStatModel d_model(4);
-            d_model.create(d_frame);
+        cv::gpu::FGDStatModel d_model(4);
+        d_model.create(d_frame);
 
-            for (int i = 0; i < 10; ++i)
-            {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-                d_frame.upload(frame);
+            d_frame.upload(frame);
 
-                startTimer(); next();
-                d_model.update(d_frame);
-                stopTimer();
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+            startTimer(); next();
+            d_model.update(d_frame);
+            stopTimer();
         }
     }
     else
@@ -737,40 +649,32 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::MOG_GPU d_mog;
-            cv::gpu::GpuMat d_foreground;
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG_GPU d_mog;
+        cv::gpu::GpuMat d_foreground;
 
-            d_mog(d_frame, d_foreground, learningRate);
+        d_mog(d_frame, d_foreground, learningRate);
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_mog(d_frame, d_foreground, learningRate);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_mog(d_frame, d_foreground, learningRate);
+            stopTimer();
         }
     }
     else
@@ -833,40 +737,32 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::MOG2_GPU d_mog2;
-            cv::gpu::GpuMat d_foreground;
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG2_GPU d_mog2;
+        cv::gpu::GpuMat d_foreground;
 
-            d_mog2(d_frame, d_foreground);
+        d_mog2(d_frame, d_foreground);
 
-            for (int i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_mog2(d_frame, d_foreground);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_mog2(d_frame, d_foreground);
+            stopTimer();
         }
     }
     else
@@ -914,47 +810,39 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame;
+        cv::gpu::MOG2_GPU d_mog2;
+        cv::gpu::GpuMat d_foreground;
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame;
-            cv::gpu::MOG2_GPU d_mog2;
-            cv::gpu::GpuMat d_foreground;
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                d_mog2(d_frame, d_foreground);
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
 
-            cv::gpu::GpuMat d_background;
-            d_mog2.getBackgroundImage(d_background);
-
-            TEST_CYCLE()
-            {
-                d_mog2.getBackgroundImage(d_background);
-            }
+            d_frame.upload(frame);
 
-            GPU_SANITY_CHECK(d_background);
+            d_mog2(d_frame, d_foreground);
         }
-        catch (...)
+
+        cv::gpu::GpuMat d_background;
+        d_mog2.getBackgroundImage(d_background);
+
+        TEST_CYCLE()
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_mog2.getBackgroundImage(d_background);
         }
+
+        GPU_SANITY_CHECK(d_background);
     }
     else
     {
@@ -1019,40 +907,32 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::VIBE_GPU d_vibe;
-            cv::gpu::GpuMat d_foreground;
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::VIBE_GPU d_vibe;
+        cv::gpu::GpuMat d_foreground;
 
-            d_vibe(d_frame, d_foreground);
+        d_vibe(d_frame, d_foreground);
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_vibe(d_frame, d_foreground);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_vibe(d_frame, d_foreground);
+            stopTimer();
         }
     }
     else
@@ -1092,47 +972,39 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::GpuMat d_fgmask;
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::GpuMat d_fgmask;
 
-            cv::gpu::GMG_GPU d_gmg;
-            d_gmg.maxFeatures = maxFeatures;
+        cv::gpu::GMG_GPU d_gmg;
+        d_gmg.maxFeatures = maxFeatures;
 
-            d_gmg(d_frame, d_fgmask);
+        d_gmg(d_frame, d_fgmask);
 
-            for (int i = 0; i < 150; ++i)
+        for (int i = 0; i < 150; ++i)
+        {
+            cap >> frame;
+            if (frame.empty())
             {
+                cap.release();
+                cap.open(inputFile);
                 cap >> frame;
-                if (frame.empty())
-                {
-                    cap.release();
-                    cap.open(inputFile);
-                    cap >> frame;
-                }
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_gmg(d_frame, d_fgmask);
-                stopTimer();
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_gmg(d_frame, d_fgmask);
+            stopTimer();
         }
     }
     else
@@ -1194,31 +1066,23 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::VideoWriter_GPU d_writer;
+        cv::gpu::VideoWriter_GPU d_writer;
 
-            cv::gpu::GpuMat d_frame;
+        cv::gpu::GpuMat d_frame;
 
-            for (int i = 0; i < 10; ++i)
-            {
-                reader >> frame;
-                ASSERT_FALSE(frame.empty());
+        for (int i = 0; i < 10; ++i)
+        {
+            reader >> frame;
+            ASSERT_FALSE(frame.empty());
 
-                d_frame.upload(frame);
+            d_frame.upload(frame);
 
-                if (!d_writer.isOpened())
-                    d_writer.open(outputFile, frame.size(), FPS);
+            if (!d_writer.isOpened())
+                d_writer.open(outputFile, frame.size(), FPS);
 
-                startTimer(); next();
-                d_writer.write(d_frame);
-                stopTimer();
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+            startTimer(); next();
+            d_writer.write(d_frame);
+            stopTimer();
         }
     }
     else
@@ -1251,27 +1115,19 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::VideoReader_GPU d_reader(inputFile);
-            ASSERT_TRUE( d_reader.isOpened() );
+        cv::gpu::VideoReader_GPU d_reader(inputFile);
+        ASSERT_TRUE( d_reader.isOpened() );
 
-            cv::gpu::GpuMat d_frame;
+        cv::gpu::GpuMat d_frame;
 
-            d_reader.read(d_frame);
+        d_reader.read(d_frame);
 
-            TEST_CYCLE_N(10)
-            {
-                d_reader.read(d_frame);
-            }
-
-            GPU_SANITY_CHECK(d_frame);
-        }
-        catch (...)
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::resetDevice();
-            throw;
+            d_reader.read(d_frame);
         }
+
+        GPU_SANITY_CHECK(d_frame);
     }
     else
     {
diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp
index 43c92ce..7873563 100644
--- a/modules/gpu/test/nvidia/main_nvidia.cpp
+++ b/modules/gpu/test/nvidia/main_nvidia.cpp
@@ -276,8 +276,6 @@ static void devNullOutput(const std::string& msg)
     (void)msg;
 }
 
-}
-
 bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path.c_str();
@@ -294,6 +292,8 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
     return testListerII.invoke();
 }
 
+}
+
 bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path;
@@ -439,4 +439,4 @@ bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel out
     return testListerVisualize.invoke();
 }
 
-#endif /* CUDA_DISABLER */
+#endif /* CUDA_DISABLER */
\ No newline at end of file
diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp
index 4a53c60..a294a3d 100644
--- a/modules/gpu/test/test_calib3d.cpp
+++ b/modules/gpu/test/test_calib3d.cpp
@@ -62,28 +62,20 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBM, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-        cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-        cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoBM_GPU bm(0, 128, 19);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoBM_GPU bm(0, 128, 19);
+    cv::gpu::GpuMat disp;
 
-        bm(loadMat(left_image), loadMat(right_image), disp);
+    bm(loadMat(left_image), loadMat(right_image), disp);
 
-        EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@@ -105,31 +97,23 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBeliefPropagation, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("stereobp/aloe-L.png");
-        cv::Mat right_image = readImage("stereobp/aloe-R.png");
-        cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat left_image  = readImage("stereobp/aloe-L.png");
+    cv::Mat right_image = readImage("stereobp/aloe-R.png");
+    cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+    cv::gpu::GpuMat disp;
 
-        bp(loadMat(left_image), loadMat(right_image), disp);
+    bp(loadMat(left_image), loadMat(right_image), disp);
 
-        cv::Mat h_disp(disp);
-        h_disp.convertTo(h_disp, disp_gold.depth());
+    cv::Mat h_disp(disp);
+    h_disp.convertTo(h_disp, disp_gold.depth());
 
-        EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@@ -151,37 +135,29 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoConstantSpaceBP, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
-        cv::Mat right_image = readImage("csstereobp/aloe-R.png");
+    cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
+    cv::Mat right_image = readImage("csstereobp/aloe-R.png");
 
-        cv::Mat disp_gold;
+    cv::Mat disp_gold;
 
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-        else
-            disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    else
+        disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
+    cv::gpu::GpuMat disp;
 
-        csbp(loadMat(left_image), loadMat(right_image), disp);
+    csbp(loadMat(left_image), loadMat(right_image), disp);
 
-        cv::Mat h_disp(disp);
-        h_disp.convertTo(h_disp, disp_gold.depth());
+    cv::Mat h_disp(disp);
+    h_disp.convertTo(h_disp, disp_gold.depth());
 
-        EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@@ -203,40 +179,32 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(TransformPoints, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
 
-        ASSERT_EQ(src.size(), dst.size());
-        ASSERT_EQ(src.type(), dst.type());
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(src.type(), dst.type());
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat rot;
-        cv::Rodrigues(rvec, rot);
+    cv::Mat rot;
+    cv::Rodrigues(rvec, rot);
 
-        for (int i = 0; i < h_dst.cols; ++i)
-        {
-            cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
+    for (int i = 0; i < h_dst.cols; ++i)
+    {
+        cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
 
-            cv::Point3f p = src.at<cv::Point3f>(0, i);
-            cv::Point3f res_gold(
-                    rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
-                    rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
-                    rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
+        cv::Point3f p = src.at<cv::Point3f>(0, i);
+        cv::Point3f res_gold(
+                rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
+                rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
+                rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
 
-            ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
     }
 }
 
@@ -259,42 +227,34 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(ProjectPoints, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-        camera_mat.at<float>(0, 1) = 0.f;
-        camera_mat.at<float>(1, 0) = 0.f;
-        camera_mat.at<float>(2, 0) = 0.f;
-        camera_mat.at<float>(2, 1) = 0.f;
-
-        cv::gpu::GpuMat dst;
-        cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
+    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+    camera_mat.at<float>(0, 1) = 0.f;
+    camera_mat.at<float>(1, 0) = 0.f;
+    camera_mat.at<float>(2, 0) = 0.f;
+    camera_mat.at<float>(2, 1) = 0.f;
 
-        ASSERT_EQ(1, dst.rows);
-        ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
+    cv::gpu::GpuMat dst;
+    cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
 
-        std::vector<cv::Point2f> dst_gold;
-        cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
+    ASSERT_EQ(1, dst.rows);
+    ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
 
-        ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
+    std::vector<cv::Point2f> dst_gold;
+    cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
 
-        cv::Mat h_dst(dst);
+    ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
 
-        for (size_t i = 0; i < dst_gold.size(); ++i)
-        {
-            cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
-            cv::Point2f res_gold = dst_gold[i];
+    cv::Mat h_dst(dst);
 
-            ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
-        }
-    }
-    catch (...)
+    for (size_t i = 0; i < dst_gold.size(); ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
+        cv::Point2f res_gold = dst_gold[i];
+
+        ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
     }
 }
 
@@ -317,36 +277,28 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(SolvePnPRansac, Accuracy)
 {
-    try
-    {
-        cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
-        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-        camera_mat.at<float>(0, 1) = 0.f;
-        camera_mat.at<float>(1, 0) = 0.f;
-        camera_mat.at<float>(2, 0) = 0.f;
-        camera_mat.at<float>(2, 1) = 0.f;
-
-        std::vector<cv::Point2f> image_vec;
-        cv::Mat rvec_gold;
-        cv::Mat tvec_gold;
-        rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
-
-        cv::Mat rvec, tvec;
-        std::vector<int> inliers;
-        cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)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-3);
-        ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
+    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+    camera_mat.at<float>(0, 1) = 0.f;
+    camera_mat.at<float>(1, 0) = 0.f;
+    camera_mat.at<float>(2, 0) = 0.f;
+    camera_mat.at<float>(2, 1) = 0.f;
+
+    std::vector<cv::Point2f> image_vec;
+    cv::Mat rvec_gold;
+    cv::Mat tvec_gold;
+    rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
+
+    cv::Mat rvec, tvec;
+    std::vector<int> inliers;
+    cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)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-3);
+    ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
@@ -374,24 +326,16 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
 
 TEST_P(ReprojectImageTo3D, Accuracy)
 {
-    try
-    {
-        cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
-        cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
+    cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
+    cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
+    cv::gpu::GpuMat dst;
+    cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
 
-        cv::Mat dst_gold;
-        cv::reprojectImageTo3D(disp, dst_gold, Q, false);
+    cv::Mat dst_gold;
+    cv::reprojectImageTo3D(disp, dst_gold, Q, false);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp
index e350ee9..2510f56 100644
--- a/modules/gpu/test/test_color.cpp
+++ b/modules/gpu/test/test_color.cpp
@@ -72,261 +72,165 @@ PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CvtColor, BGR2RGB)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2RGBA)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2BGRA)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2RGBA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2GRAY)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2GRAY)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, GRAY2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2GRAY)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2GRAY)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2BGR565)
@@ -334,23 +238,15 @@ TEST_P(CvtColor, BGR2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGB2BGR565)
@@ -358,23 +254,15 @@ TEST_P(CvtColor, RGB2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652BGR)
@@ -382,24 +270,16 @@ TEST_P(CvtColor, BGR5652BGR)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652RGB)
@@ -407,24 +287,16 @@ TEST_P(CvtColor, BGR5652RGB)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR565)
@@ -432,24 +304,16 @@ TEST_P(CvtColor, BGRA2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGBA2BGR565)
@@ -457,24 +321,16 @@ TEST_P(CvtColor, RGBA2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652BGRA)
@@ -482,24 +338,16 @@ TEST_P(CvtColor, BGR5652BGRA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652RGBA)
@@ -507,24 +355,16 @@ TEST_P(CvtColor, BGR5652RGBA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGR565)
@@ -532,24 +372,16 @@ TEST_P(CvtColor, GRAY2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652GRAY)
@@ -557,24 +389,16 @@ TEST_P(CvtColor, BGR5652GRAY)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2BGR555)
@@ -582,23 +406,15 @@ TEST_P(CvtColor, BGR2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGB2BGR555)
@@ -606,23 +422,15 @@ TEST_P(CvtColor, RGB2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552BGR)
@@ -630,24 +438,16 @@ TEST_P(CvtColor, BGR5552BGR)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552RGB)
@@ -655,24 +455,16 @@ TEST_P(CvtColor, BGR5552RGB)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR555)
@@ -680,24 +472,16 @@ TEST_P(CvtColor, BGRA2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGBA2BGR555)
@@ -705,24 +489,16 @@ TEST_P(CvtColor, RGBA2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552BGRA)
@@ -730,24 +506,16 @@ TEST_P(CvtColor, BGR5552BGRA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552RGBA)
@@ -755,24 +523,16 @@ TEST_P(CvtColor, BGR5552RGBA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGR555)
@@ -780,24 +540,16 @@ TEST_P(CvtColor, GRAY2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552GRAY)
@@ -805,422 +557,286 @@ TEST_P(CvtColor, BGR5552GRAY)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2XYZ)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2XYZ)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2XYZ4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGRA2XYZ4)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ42BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ42BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YCrCb)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2YCrCb)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YCrCb4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2YCrCb4)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb42RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb42RGBA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2HSV)
@@ -1228,23 +844,15 @@ TEST_P(CvtColor, BGR2HSV)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV)
@@ -1252,23 +860,15 @@ TEST_P(CvtColor, RGB2HSV)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV4)
@@ -1276,31 +876,23 @@ TEST_P(CvtColor, RGB2HSV4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HSV4)
@@ -1308,32 +900,24 @@ TEST_P(CvtColor, RGBA2HSV4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HLS)
@@ -1341,23 +925,15 @@ TEST_P(CvtColor, BGR2HLS)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS)
@@ -1365,23 +941,15 @@ TEST_P(CvtColor, RGB2HLS)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS4)
@@ -1389,31 +957,23 @@ TEST_P(CvtColor, RGB2HLS4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HLS4)
@@ -1421,32 +981,24 @@ TEST_P(CvtColor, RGBA2HLS4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2BGR)
@@ -1454,24 +1006,16 @@ TEST_P(CvtColor, HSV2BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2RGB)
@@ -1479,24 +1023,16 @@ TEST_P(CvtColor, HSV2RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42BGR)
@@ -1504,29 +1040,21 @@ TEST_P(CvtColor, HSV42BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42BGRA)
@@ -1534,29 +1062,21 @@ TEST_P(CvtColor, HSV42BGRA)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2BGR)
@@ -1564,24 +1084,16 @@ TEST_P(CvtColor, HLS2BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2RGB)
@@ -1589,24 +1101,16 @@ TEST_P(CvtColor, HLS2RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGB)
@@ -1614,29 +1118,21 @@ TEST_P(CvtColor, HLS42RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGBA)
@@ -1644,30 +1140,22 @@ TEST_P(CvtColor, HLS42RGBA)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HSV_FULL)
@@ -1675,23 +1163,15 @@ TEST_P(CvtColor, BGR2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV_FULL)
@@ -1699,23 +1179,15 @@ TEST_P(CvtColor, RGB2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV4_FULL)
@@ -1723,31 +1195,23 @@ TEST_P(CvtColor, RGB2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HSV4_FULL)
@@ -1755,32 +1219,24 @@ TEST_P(CvtColor, RGBA2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HLS_FULL)
@@ -1788,23 +1244,15 @@ TEST_P(CvtColor, BGR2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS_FULL)
@@ -1812,23 +1260,15 @@ TEST_P(CvtColor, RGB2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS4_FULL)
@@ -1836,31 +1276,23 @@ TEST_P(CvtColor, RGB2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HLS4_FULL)
@@ -1868,32 +1300,24 @@ TEST_P(CvtColor, RGBA2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2BGR_FULL)
@@ -1901,24 +1325,16 @@ TEST_P(CvtColor, HSV2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2RGB_FULL)
@@ -1926,24 +1342,16 @@ TEST_P(CvtColor, HSV2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42RGB_FULL)
@@ -1951,29 +1359,21 @@ TEST_P(CvtColor, HSV42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42RGBA_FULL)
@@ -1981,29 +1381,21 @@ TEST_P(CvtColor, HSV42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2BGR_FULL)
@@ -2011,24 +1403,16 @@ TEST_P(CvtColor, HLS2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2RGB_FULL)
@@ -2036,24 +1420,16 @@ TEST_P(CvtColor, HLS2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGB_FULL)
@@ -2061,29 +1437,21 @@ TEST_P(CvtColor, HLS42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGBA_FULL)
@@ -2091,405 +1459,335 @@ TEST_P(CvtColor, HLS42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2YUV)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2YUV)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV42BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV42BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YUV4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2YUV4)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2Lab)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
+    {
+        cv::Mat src = readImage("stereobm/aloe-L.png");
 
-        cv::Mat h_dst(dst);
+        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(src, dst_bgr, 10);
     }
-    catch (...)
+    catch (const cv::Exception& e)
     {
-        cv::gpu::resetDevice();
-        throw;
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
     }
 }
 
-#if defined(CUDA_VERSION) && (CUDA_VERSION >= 5000)
-    TEST_P(CvtColor, BGR2Lab)
+TEST_P(CvtColor, RGB2Lab)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = readImage("stereobm/aloe-L.png");
-
-            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
-
-            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
-
-            EXPECT_MAT_NEAR(src, dst_bgr, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
+        cv::Mat src = readImage("stereobm/aloe-L.png");
+
+        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
 
-    TEST_P(CvtColor, RGB2Lab)
+        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
+
+        EXPECT_MAT_NEAR(src, dst_bgr, 10);
+    }
+    catch (const cv::Exception& e)
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = readImage("stereobm/aloe-L.png");
-
-            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
-
-            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
-
-            EXPECT_MAT_NEAR(src, dst_bgr, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
     }
+}
+
+TEST_P(CvtColor, BGR2Luv)
+{
+    if (depth != CV_8U)
+        return;
 
-    TEST_P(CvtColor, BGR2Luv)
+    try
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = img;
-
-            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
-
-            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
-
-            EXPECT_MAT_NEAR(src, dst_rgb, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
+        cv::Mat src = img;
+
+        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
 
-    TEST_P(CvtColor, RGB2Luv)
+        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
+
+        EXPECT_MAT_NEAR(src, dst_rgb, 10);
+    }
+    catch (const cv::Exception& e)
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = img;
-
-            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
-
-            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
-
-            EXPECT_MAT_NEAR(src, dst_rgb, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
     }
+}
+
+TEST_P(CvtColor, RGB2Luv)
+{
+    if (depth != CV_8U)
+        return;
 
-    TEST_P(CvtColor, RGBA2mRGBA)
+    try
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
-
-            cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
-
-            cv::Mat dst_gold;
-            cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        cv::Mat src = img;
+
+        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
+
+        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
+
+        EXPECT_MAT_NEAR(src, dst_rgb, 10);
     }
+    catch (const cv::Exception& e)
+    {
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
 #endif
+    }
+}
 
-TEST_P(CvtColor, BayerBG2BGR)
+TEST_P(CvtColor, RGBA2mRGBA)
 {
-    if ((depth != CV_8U && depth != CV_16U) || useRoi)
+    if (depth != CV_8U)
         return;
 
     try
     {
-        cv::Mat src = randomMat(size, depth);
+        cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
 
         cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1);
     }
-    catch (...)
+    catch (const cv::Exception& e)
     {
-        cv::gpu::resetDevice();
-        throw;
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
     }
 }
 
+TEST_P(CvtColor, BayerBG2BGR)
+{
+    if ((depth != CV_8U && depth != CV_16U) || useRoi)
+        return;
+
+    cv::Mat src = randomMat(size, depth);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+}
+
 TEST_P(CvtColor, BayerBG2BGR4)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGB2BGR)
@@ -2497,23 +1795,15 @@ TEST_P(CvtColor, BayerGB2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGB2BGR4)
@@ -2521,29 +1811,21 @@ TEST_P(CvtColor, BayerGB2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerRG2BGR)
@@ -2551,23 +1833,15 @@ TEST_P(CvtColor, BayerRG2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerRG2BGR4)
@@ -2575,29 +1849,21 @@ TEST_P(CvtColor, BayerRG2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGR2BGR)
@@ -2605,23 +1871,15 @@ TEST_P(CvtColor, BayerGR2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGR2BGR4)
@@ -2629,29 +1887,21 @@ TEST_P(CvtColor, BayerGR2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
@@ -2681,26 +1931,18 @@ PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(SwapChannels, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
 
-        const int dstOrder[] = {2, 1, 0, 3};
-        cv::gpu::swapChannels(d_src, dstOrder);
+    const int dstOrder[] = {2, 1, 0, 3};
+    cv::gpu::swapChannels(d_src, dstOrder);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp
index 7c9bb35..0efd9ec 100644
--- a/modules/gpu/test/test_copy_make_border.cpp
+++ b/modules/gpu/test/test_copy_make_border.cpp
@@ -71,24 +71,16 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
 
 TEST_P(CopyMakeBorder, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar val = randomScalar(0, 255);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar val = randomScalar(0, 255);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
-        cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
+    cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
+    cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
 
-        cv::Mat dst_gold;
-        cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
+    cv::Mat dst_gold;
+    cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index d943ec7..695ec97 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -70,44 +70,36 @@ PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Merge, Accuracy)
 {
-    try
-    {
-        std::vector<cv::Mat> src;
-        src.reserve(channels);
-        for (int i = 0; i < channels; ++i)
-            src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
+    std::vector<cv::Mat> src;
+    src.reserve(channels);
+    for (int i = 0; i < channels; ++i)
+        src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
 
-        std::vector<cv::gpu::GpuMat> d_src;
-        for (int i = 0; i < channels; ++i)
-            d_src.push_back(loadMat(src[i], useRoi));
+    std::vector<cv::gpu::GpuMat> d_src;
+    for (int i = 0; i < channels; ++i)
+        d_src.push_back(loadMat(src[i], useRoi));
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::merge(d_src, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             cv::gpu::GpuMat dst;
             cv::gpu::merge(d_src, dst);
-
-            cv::Mat dst_gold;
-            cv::merge(src, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst;
+        cv::gpu::merge(d_src, dst);
+
+        cv::Mat dst_gold;
+        cv::merge(src, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -147,43 +139,35 @@ PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Split, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                std::vector<cv::gpu::GpuMat> dst;
-                cv::gpu::split(loadMat(src), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            std::vector<cv::gpu::GpuMat> dst;
+            cv::gpu::split(loadMat(src), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            std::vector<cv::gpu::GpuMat> dst;
-            cv::gpu::split(loadMat(src, useRoi), dst);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        std::vector<cv::gpu::GpuMat> dst;
+        cv::gpu::split(loadMat(src, useRoi), dst);
 
-            std::vector<cv::Mat> dst_gold;
-            cv::split(src, dst_gold);
+        std::vector<cv::Mat> dst_gold;
+        cv::split(src, dst_gold);
 
-            ASSERT_EQ(dst_gold.size(), dst.size());
+        ASSERT_EQ(dst_gold.size(), dst.size());
 
-            for (size_t i = 0; i < dst_gold.size(); ++i)
-            {
-                EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
-            }
+        for (size_t i = 0; i < dst_gold.size(); ++i)
+        {
+            EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Split, testing::Combine(
@@ -224,39 +208,31 @@ PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, Ma
 
 TEST_P(Add_Array, Accuracy)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -293,40 +269,32 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Add_Array_Mask, Accuracy)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::add(mat1, mat2, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -359,78 +327,62 @@ PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, M
 
 TEST_P(Add_Scalar, WithOutMask)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Add_Scalar, WithMask)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::add(mat, val, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::add(mat, val, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -471,39 +423,31 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Subtract_Array, Accuracy)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -540,40 +484,32 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<Ma
 
 TEST_P(Subtract_Array_Mask, Accuracy)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -606,78 +542,62 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Subtract_Scalar, WithOutMask)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Subtract_Scalar, WithMask)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::subtract(mat, val, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::subtract(mat, val, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -718,76 +638,60 @@ PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Multiply_Array, WithOutScale)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 
 TEST_P(Multiply_Array, WithScale)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    double scale = randomDouble(0.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
     }
 }
 
@@ -819,92 +723,76 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, CV_8UC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1);
+    cv::Mat mat1 = randomMat(size, CV_8UC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        for (int y = 0; y < h_dst.rows; ++y)
-        {
-            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+    for (int y = 0; y < h_dst.rows; ++y)
+    {
+        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4b val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4b actual = dst_row[x];
+        for (int x = 0; x < h_dst.cols; ++x)
+        {
+            cv::Vec4b val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4b actual = dst_row[x];
 
-                cv::Vec4b gold;
+            cv::Vec4b gold;
 
-                gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
-                gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
-                gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
-                gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
+            gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
+            gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
+            gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
+            gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
 
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, CV_16SC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1);
+    cv::Mat mat1 = randomMat(size, CV_16SC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        for (int y = 0; y < h_dst.rows; ++y)
-        {
-            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+    for (int y = 0; y < h_dst.rows; ++y)
+    {
+        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4s val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4s actual = dst_row[x];
+        for (int x = 0; x < h_dst.cols; ++x)
+        {
+            cv::Vec4s val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4s actual = dst_row[x];
 
-                cv::Vec4s gold;
+            cv::Vec4s gold;
 
-                gold[0] = cv::saturate_cast<short>(val1[0] * val2);
-                gold[1] = cv::saturate_cast<short>(val1[1] * val2);
-                gold[2] = cv::saturate_cast<short>(val1[2] * val2);
-                gold[3] = cv::saturate_cast<short>(val1[3] * val2);
+            gold[0] = cv::saturate_cast<short>(val1[0] * val2);
+            gold[1] = cv::saturate_cast<short>(val1[1] * val2);
+            gold[2] = cv::saturate_cast<short>(val1[2] * val2);
+            gold[3] = cv::saturate_cast<short>(val1[3] * val2);
 
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Multiply_Array_Special, testing::Combine(
@@ -935,77 +823,61 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Multiply_Scalar, WithOutScale)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat, val, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat, val, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
 
 TEST_P(Multiply_Scalar, WithScale)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    double scale = randomDouble(0.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat, val, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat, val, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
@@ -1046,77 +918,61 @@ PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth,
 
 TEST_P(Divide_Array, WithOutScale)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat1, mat2, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat1, mat2, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
     }
 }
 
 
 TEST_P(Divide_Array, WithScale)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-        double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+    double scale = randomDouble(0.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat1, mat2, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat1, mat2, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
     }
 }
 
@@ -1148,92 +1004,76 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, CV_8UC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+    cv::Mat mat1 = randomMat(size, CV_8UC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        for (int y = 0; y < h_dst.rows; ++y)
-        {
-            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+    for (int y = 0; y < h_dst.rows; ++y)
+    {
+        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4b val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4b actual = dst_row[x];
+        for (int x = 0; x < h_dst.cols; ++x)
+        {
+            cv::Vec4b val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4b actual = dst_row[x];
 
-                cv::Vec4b gold;
+            cv::Vec4b gold;
 
-                gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
-                gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
-                gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
-                gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
+            gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
+            gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
+            gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
+            gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
 
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
 {
-    try
-    {
-        cv::Mat mat1 = randomMat(size, CV_16SC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+    cv::Mat mat1 = randomMat(size, CV_16SC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        for (int y = 0; y < h_dst.rows; ++y)
-        {
-            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+    for (int y = 0; y < h_dst.rows; ++y)
+    {
+        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4s val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4s actual = dst_row[x];
+        for (int x = 0; x < h_dst.cols; ++x)
+        {
+            cv::Vec4s val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4s actual = dst_row[x];
 
-                cv::Vec4s gold;
+            cv::Vec4s gold;
 
-                gold[0] = cv::saturate_cast<short>(val1[0] / val2);
-                gold[1] = cv::saturate_cast<short>(val1[1] / val2);
-                gold[2] = cv::saturate_cast<short>(val1[2] / val2);
-                gold[3] = cv::saturate_cast<short>(val1[3] / val2);
+            gold[0] = cv::saturate_cast<short>(val1[0] / val2);
+            gold[1] = cv::saturate_cast<short>(val1[1] / val2);
+            gold[2] = cv::saturate_cast<short>(val1[2] / val2);
+            gold[3] = cv::saturate_cast<short>(val1[3] / val2);
 
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Divide_Array_Special, testing::Combine(
@@ -1264,76 +1104,60 @@ PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth
 
 TEST_P(Divide_Scalar, WithOutScale)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(1.0, 255.0);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(1.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat, val, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat, val, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Divide_Scalar, WithScale)
 {
-    try
-    {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(1.0, 255.0);
-        double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(1.0, 255.0);
+    double scale = randomDouble(0.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat, val, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat, val, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 
@@ -1366,38 +1190,30 @@ PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatD
 
 TEST_P(Divide_Scalar_Inv, Accuracy)
 {
-    try
-    {
-        double scale = randomDouble(0.0, 255.0);
-        cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
+    double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
 
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(scale, mat, dst_gold, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(scale, mat, dst_gold, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -1430,75 +1246,59 @@ PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(AbsDiff, Array)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold;
-            cv::absdiff(src1, src2, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold;
+        cv::absdiff(src1, src2, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(AbsDiff, Scalar)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, depth);
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::absdiff(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::absdiff(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold;
-            cv::absdiff(src, val, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold;
+        cv::absdiff(src, val, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
     }
 }
 
@@ -1531,22 +1331,14 @@ PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Abs, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::abs(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::abs(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold = cv::abs(src);
+    cv::Mat dst_gold = cv::abs(src);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
@@ -1578,23 +1370,15 @@ PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqr, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
+    cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::sqr(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::sqr(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::multiply(src, src, dst_gold);
+    cv::Mat dst_gold;
+    cv::multiply(src, src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
@@ -1653,23 +1437,15 @@ PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqrt, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::sqrt(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::sqrt(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        sqrtGold(src, dst_gold);
+    cv::Mat dst_gold;
+    sqrtGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
@@ -1728,23 +1504,15 @@ PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Log, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 1.0, 255.0);
+    cv::Mat src = randomMat(size, depth, 1.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::log(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::log(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        logGold(src, dst_gold);
+    cv::Mat dst_gold;
+    logGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
@@ -1813,23 +1581,15 @@ PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Exp, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::exp(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::exp(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        expGold(src, dst_gold);
+    cv::Mat dst_gold;
+    expGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
@@ -1869,38 +1629,30 @@ PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode,
 
 TEST_P(Compare_Array, Accuracy)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
-            cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
-
-            cv::Mat dst_gold;
-            cv::compare(src1, src2, dst_gold, cmp_code);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
+        cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
+
+        cv::Mat dst_gold;
+        cv::compare(src1, src2, dst_gold, cmp_code);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -1979,47 +1731,39 @@ PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode,
 
 TEST_P(Compare_Scalar, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar sc = randomScalar(0.0, 255.0);
+
+    if (src.depth() < CV_32F)
     {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar sc = randomScalar(0.0, 255.0);
+        sc.val[0] = cvRound(sc.val[0]);
+        sc.val[1] = cvRound(sc.val[1]);
+        sc.val[2] = cvRound(sc.val[2]);
+        sc.val[3] = cvRound(sc.val[3]);
+    }
 
-        if (src.depth() < CV_32F)
+    if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            sc.val[0] = cvRound(sc.val[0]);
-            sc.val[1] = cvRound(sc.val[1]);
-            sc.val[2] = cvRound(sc.val[2]);
-            sc.val[3] = cvRound(sc.val[3]);
+            cv::gpu::GpuMat dst;
+            cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
         }
-
-        if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        catch (const cv::Exception& e)
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
-        else
-        {
-            cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
+    }
+    else
+    {
+        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
 
-            cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
+        cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
 
-            cv::Mat dst_gold;
-            compareScalarGold(src, sc, dst_gold, cmp_code);
+        cv::Mat dst_gold;
+        compareScalarGold(src, sc, dst_gold, cmp_code);
 
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2057,74 +1801,42 @@ PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(Bitwise_Array, Not)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_not(loadMat(src1), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_not(loadMat(src1), dst);
 
-        cv::Mat dst_gold = ~src1;
+    cv::Mat dst_gold = ~src1;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, Or)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 | src2;
+    cv::Mat dst_gold = src1 | src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, And)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 & src2;
+    cv::Mat dst_gold = src1 & src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, Xor)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 ^ src2;
+    cv::Mat dst_gold = src1 ^ src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Array, testing::Combine(
@@ -2162,59 +1874,35 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channel
 
 TEST_P(Bitwise_Scalar, Or)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_or(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_or(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_or(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_or(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Scalar, And)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_and(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_and(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_and(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_and(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Scalar, Xor)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_xor(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_xor(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_xor(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_xor(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
@@ -2276,25 +1964,17 @@ PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(RShift, Accuracy)
 {
-    try
-    {
-        int type = CV_MAKE_TYPE(depth, channels);
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    int type = CV_MAKE_TYPE(depth, channels);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::rshift(loadMat(src, useRoi), val, dst);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::rshift(loadMat(src, useRoi), val, dst);
 
-        cv::Mat dst_gold;
-        rhiftGold(src, val, dst_gold);
+    cv::Mat dst_gold;
+    rhiftGold(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine(
@@ -2361,25 +2041,17 @@ PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(LShift, Accuracy)
 {
-    try
-    {
-        int type = CV_MAKE_TYPE(depth, channels);
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    int type = CV_MAKE_TYPE(depth, channels);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::lshift(loadMat(src, useRoi), val, dst);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::lshift(loadMat(src, useRoi), val, dst);
 
-        cv::Mat dst_gold;
-        lhiftGold(src, val, dst_gold);
+    cv::Mat dst_gold;
+    lhiftGold(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LShift, testing::Combine(
@@ -2412,73 +2084,57 @@ PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Min, Array)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::min(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::min(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold = cv::min(src1, src2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold = cv::min(src1, src2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(Min, Scalar)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        double val = randomDouble(0.0, 255.0);
+    cv::Mat src = randomMat(size, depth);
+    double val = randomDouble(0.0, 255.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::min(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::min(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::min(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold = cv::min(src, val);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::min(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold = cv::min(src, val);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2511,73 +2167,57 @@ PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Max, Array)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::max(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::max(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold = cv::max(src1, src2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold = cv::max(src1, src2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(Max, Scalar)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        double val = randomDouble(0.0, 255.0);
+    cv::Mat src = randomMat(size, depth);
+    double val = randomDouble(0.0, 255.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::max(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::max(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::max(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold = cv::max(src, val);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::max(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold = cv::max(src, val);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2610,41 +2250,33 @@ PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Pow, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
-        double power = randomDouble(2.0, 4.0);
+    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+    double power = randomDouble(2.0, 4.0);
 
-        if (src.depth() < CV_32F)
-            power = static_cast<int>(power);
+    if (src.depth() < CV_32F)
+        power = static_cast<int>(power);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::pow(loadMat(src), power, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::pow(loadMat(src), power, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::pow(loadMat(src, useRoi), power, dst);
-
-            cv::Mat dst_gold;
-            cv::pow(src, power, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::pow(loadMat(src, useRoi), power, dst);
+
+        cv::Mat dst_gold;
+        cv::pow(src, power, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
     }
 }
 
@@ -2681,41 +2313,33 @@ PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth,
 
 TEST_P(AddWeighted, Accuracy)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, depth1);
-        cv::Mat src2 = randomMat(size, depth2);
-        double alpha = randomDouble(-10.0, 10.0);
-        double beta = randomDouble(-10.0, 10.0);
-        double gamma = randomDouble(-10.0, 10.0);
+    cv::Mat src1 = randomMat(size, depth1);
+    cv::Mat src2 = randomMat(size, depth2);
+    double alpha = randomDouble(-10.0, 10.0);
+    double beta = randomDouble(-10.0, 10.0);
+    double gamma = randomDouble(-10.0, 10.0);
 
-        if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
-            cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
-
-            cv::Mat dst_gold;
-            cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
+        cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
+
+        cv::Mat dst_gold;
+        cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
     }
 }
 
@@ -2730,8 +2354,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // GEMM
 
-#ifdef HAVE_CUBLAS
-
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
 #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
 
@@ -2757,54 +2379,58 @@ PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
 
 TEST_P(GEMM, Accuracy)
 {
+    cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
+    cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
+    cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
+    double alpha = randomDouble(-10.0, 10.0);
+    double beta = randomDouble(-10.0, 10.0);
+
+#ifndef HAVE_CUBLAS
     try
     {
-        cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
-        cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
-        cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
-        double alpha = randomDouble(-10.0, 10.0);
-        double beta = randomDouble(-10.0, 10.0);
-
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        cv::gpu::GpuMat dst;
+        cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+    }
+    catch (const cv::Exception& e)
+    {
+        ASSERT_EQ(CV_StsNotImplemented, e.code);
+    }
+#else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
         }
-        else if (type == CV_64FC2 && flags != 0)
+        catch (const cv::Exception& e)
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
-        else
+    }
+    else if (type == CV_64FC2 && flags != 0)
+    {
+        try
         {
-            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-            cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
-
-            cv::Mat dst_gold;
-            cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+            cv::gpu::GpuMat dst;
+            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
+
+        cv::Mat dst_gold;
+        cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
     }
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
@@ -2814,8 +2440,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
     ALL_GEMM_FLAGS,
     WHOLE_SUBMAT));
 
-#endif // HAVE_CUBLAS
-
 ////////////////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -2839,37 +2463,29 @@ PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Transpose, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::transpose(loadMat(src), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::transpose(loadMat(src), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
-            cv::gpu::transpose(loadMat(src, useRoi), dst);
-
-            cv::Mat dst_gold;
-            cv::transpose(src, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
+        cv::gpu::transpose(loadMat(src, useRoi), dst);
+
+        cv::Mat dst_gold;
+        cv::transpose(src, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2914,23 +2530,15 @@ PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
 
 TEST_P(Flip, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
 
-        cv::Mat dst_gold;
-        cv::flip(src, dst_gold, flip_code);
+    cv::Mat dst_gold;
+    cv::flip(src, dst_gold, flip_code);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Flip, testing::Combine(
@@ -2974,46 +2582,30 @@ PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(LUT, OneChannel)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
-        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
+    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-        cv::Mat dst_gold;
-        cv::LUT(src, lut, dst_gold);
+    cv::Mat dst_gold;
+    cv::LUT(src, lut, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(LUT, MultiChannel)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
+    cv::Mat src = randomMat(size, type);
+    cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
 
-        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
-        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
+    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-        cv::Mat dst_gold;
-        cv::LUT(src, lut, dst_gold);
+    cv::Mat dst_gold;
+    cv::LUT(src, lut, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LUT, testing::Combine(
@@ -3043,94 +2635,62 @@ PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Magnitude, NPP)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC2);
+    cv::Mat src = randomMat(size, CV_32FC2);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitude(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitude(loadMat(src, useRoi), dst);
 
-        cv::Mat arr[2];
-        cv::split(src, arr);
-        cv::Mat dst_gold;
-        cv::magnitude(arr[0], arr[1], dst_gold);
+    cv::Mat arr[2];
+    cv::split(src, arr);
+    cv::Mat dst_gold;
+    cv::magnitude(arr[0], arr[1], dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
 TEST_P(Magnitude, Sqr_NPP)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC2);
+    cv::Mat src = randomMat(size, CV_32FC2);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
 
-        cv::Mat arr[2];
-        cv::split(src, arr);
-        cv::Mat dst_gold;
-        cv::magnitude(arr[0], arr[1], dst_gold);
-        cv::multiply(dst_gold, dst_gold, dst_gold);
+    cv::Mat arr[2];
+    cv::split(src, arr);
+    cv::Mat dst_gold;
+    cv::magnitude(arr[0], arr[1], dst_gold);
+    cv::multiply(dst_gold, dst_gold, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
 }
 
 TEST_P(Magnitude, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::magnitude(x, y, dst_gold);
+    cv::Mat dst_gold;
+    cv::magnitude(x, y, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
 TEST_P(Magnitude, Sqr_Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::magnitude(x, y, dst_gold);
-        cv::multiply(dst_gold, dst_gold, dst_gold);
+    cv::Mat dst_gold;
+    cv::magnitude(x, y, dst_gold);
+    cv::multiply(dst_gold, dst_gold, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine(
@@ -3163,24 +2723,16 @@ PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
 
 TEST_P(Phase, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
 
-        cv::Mat dst_gold;
-        cv::phase(x, y, dst_gold, angleInDegrees);
+    cv::Mat dst_gold;
+    cv::phase(x, y, dst_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Phase, testing::Combine(
@@ -3212,27 +2764,19 @@ PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(CartToPolar, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
+    cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
 
-        cv::Mat mag_gold;
-        cv::Mat angle_gold;
-        cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
+    cv::Mat mag_gold;
+    cv::Mat angle_gold;
+    cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
-        EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+    EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, CartToPolar, testing::Combine(
@@ -3264,27 +2808,19 @@ PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(PolarToCart, Accuracy)
 {
-    try
-    {
-        cv::Mat magnitude = randomMat(size, CV_32FC1);
-        cv::Mat angle = randomMat(size, CV_32FC1);
+    cv::Mat magnitude = randomMat(size, CV_32FC1);
+    cv::Mat angle = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
+    cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
 
-        cv::Mat x_gold;
-        cv::Mat y_gold;
-        cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
+    cv::Mat x_gold;
+    cv::Mat y_gold;
+    cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(x_gold, x, 1e-4);
-        EXPECT_MAT_NEAR(y_gold, y, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+    EXPECT_MAT_NEAR(y_gold, y, 1e-4);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, PolarToCart, testing::Combine(
@@ -3314,41 +2850,33 @@ PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(MeanStdDev, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
-        {
-            try
-            {
-                cv::Scalar mean;
-                cv::Scalar stddev;
-                cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
-        }
-        else
+    if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+    {
+        try
         {
             cv::Scalar mean;
             cv::Scalar stddev;
             cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-
-            cv::Scalar mean_gold;
-            cv::Scalar stddev_gold;
-            cv::meanStdDev(src, mean_gold, stddev_gold);
-
-            EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
-            EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Scalar mean;
+        cv::Scalar stddev;
+        cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+
+        cv::Scalar mean_gold;
+        cv::Scalar stddev_gold;
+        cv::meanStdDev(src, mean_gold, stddev_gold);
+
+        EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
+        EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
     }
 }
 
@@ -3382,21 +2910,13 @@ PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
 
 TEST_P(Norm, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
+    double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
 
-        double val_gold = cv::norm(src, normCode);
+    double val_gold = cv::norm(src, normCode);
 
-        EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine(
@@ -3434,22 +2954,14 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
 
 TEST_P(NormDiff, Accuracy)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, CV_8UC1);
-        cv::Mat src2 = randomMat(size, CV_8UC1);
+    cv::Mat src1 = randomMat(size, CV_8UC1);
+    cv::Mat src2 = randomMat(size, CV_8UC1);
 
-        double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
+    double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
 
-        double val_gold = cv::norm(src1, src2, normCode);
+    double val_gold = cv::norm(src1, src2, normCode);
 
-        EXPECT_NEAR(val_gold, val, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_NEAR(val_gold, val, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine(
@@ -3562,53 +3074,29 @@ PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Sum, Simple)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = cv::sum(src);
+    cv::Scalar val_gold = cv::sum(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 TEST_P(Sum, Abs)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = absSumGold(src);
+    cv::Scalar val_gold = absSumGold(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 TEST_P(Sum, Sqr)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = sqrSumGold(src);
+    cv::Scalar val_gold = sqrSumGold(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
@@ -3640,115 +3128,91 @@ PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMax, WithoutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            double minVal, maxVal;
+            cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
 TEST_P(MinMax, WithMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat src = randomMat(size, depth);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            double minVal, maxVal;
+            cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
 TEST_P(MinMax, NullPtr)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, 0);
-                cv::gpu::minMax(loadMat(src), 0, &maxVal);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            double minVal, maxVal;
+            cv::gpu::minMax(loadMat(src), &minVal, 0);
+            cv::gpu::minMax(loadMat(src), 0, &maxVal);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
-            cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
+        cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
@@ -3805,114 +3269,82 @@ PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMaxLoc, WithoutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
 TEST_P(MinMaxLoc, WithMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat src = randomMat(size, depth);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
 TEST_P(MinMaxLoc, NullPtr)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
@@ -3920,22 +3352,30 @@ TEST_P(MinMaxLoc, NullPtr)
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
@@ -3969,36 +3409,28 @@ PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CountNonZero, Accuracy)
 {
-    try
-    {
-        cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
-        cv::Mat src;
-        srcBase.convertTo(src, depth);
+    cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
+    cv::Mat src;
+    srcBase.convertTo(src, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::countNonZero(loadMat(src));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::countNonZero(loadMat(src));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            int val = cv::gpu::countNonZero(loadMat(src, useRoi));
-
-            int val_gold = cv::countNonZero(src);
-
-            ASSERT_EQ(val_gold, val);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        int val = cv::gpu::countNonZero(loadMat(src, useRoi));
+
+        int val_gold = cv::countNonZero(src);
+
+        ASSERT_EQ(val_gold, val);
     }
 }
 
@@ -4054,47 +3486,31 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
 
 TEST_P(Reduce, Rows)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
-        cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
+    cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
 
-        cv::Mat dst_gold;
-        cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
+    cv::Mat dst_gold;
+    cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
 }
 
 TEST_P(Reduce, Cols)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
-        cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
+    cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
 
-        cv::Mat dst_gold;
-        cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
-        dst_gold.cols = dst_gold.rows;
-        dst_gold.rows = 1;
-        dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+    cv::Mat dst_gold;
+    cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
+    dst_gold.cols = dst_gold.rows;
+    dst_gold.rows = 1;
+    dst_gold.step = dst_gold.cols * dst_gold.elemSize();
 
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
diff --git a/modules/gpu/test/test_denoising.cpp b/modules/gpu/test/test_denoising.cpp
index 5edf973..80bf3db 100644
--- a/modules/gpu/test/test_denoising.cpp
+++ b/modules/gpu/test/test_denoising.cpp
@@ -71,25 +71,17 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(BilateralFilter, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        src.convertTo(src, type);
-        cv::gpu::GpuMat dst;
+    src.convertTo(src, type);
+    cv::gpu::GpuMat dst;
 
-        cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
+    cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
 
-        cv::Mat dst_gold;
-        cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
+    cv::Mat dst_gold;
+    cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
@@ -115,41 +107,35 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BruteForceNonLocalMeans, Regression)
 {
-    try
-    {
-        using cv::gpu::GpuMat;
+    using cv::gpu::GpuMat;
 
-        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-        ASSERT_FALSE(bgr.empty());
+    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+    ASSERT_FALSE(bgr.empty());
 
-        cv::Mat gray;
-        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+    cv::Mat gray;
+    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-        GpuMat dbgr, dgray;
-        cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
-        cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
+    GpuMat dbgr, dgray;
+    cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
+    cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
 
-    #if 0
-        dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-        dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#if 0
+    dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+    dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
 
-        cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-        cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+    cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+    cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
-        EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
+    EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
 
+
+
 ////////////////////////////////////////////////////////
 // Fast Force Non local means
 
@@ -166,41 +152,34 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastNonLocalMeans, Regression)
 {
-    try
-    {
-        using cv::gpu::GpuMat;
+    using cv::gpu::GpuMat;
 
-        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-        ASSERT_FALSE(bgr.empty());
+    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+    ASSERT_FALSE(bgr.empty());
 
-        cv::Mat gray;
-        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+    cv::Mat gray;
+    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-        GpuMat dbgr, dgray;
-        cv::gpu::FastNonLocalMeansDenoising fnlmd;
+    GpuMat dbgr, dgray;
+    cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
-        fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
+    fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
+    fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
 
-    #if 0
-        //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-        //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#if 0
+    //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+    //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
 
-        cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-        cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+    cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+    cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
-        EXPECT_MAT_NEAR(gray_gold, dgray, 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
+    EXPECT_MAT_NEAR(gray_gold, dgray, 1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
 
+
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index a20ae68..c76fe91 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -180,19 +180,31 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
 
 TEST_P(SURF, Detector)
 {
-    try
-    {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -212,31 +224,38 @@ TEST_P(SURF, Detector)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Detector_Masked)
 {
-    try
-    {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
 
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), loadMat(mask), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), loadMat(mask), keypoints);
 
@@ -256,35 +275,43 @@ TEST_P(SURF, Detector_Masked)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Descriptor)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    cv::SURF surf_gold;
+    surf_gold.hessianThreshold = hessianThreshold;
+    surf_gold.nOctaves = nOctaves;
+    surf_gold.nOctaveLayers = nOctaveLayers;
+    surf_gold.extended = extended;
+    surf_gold.upright = upright;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
-
-        cv::SURF surf_gold;
-        surf_gold.hessianThreshold = hessianThreshold;
-        surf_gold.nOctaves = nOctaves;
-        surf_gold.nOctaveLayers = nOctaveLayers;
-        surf_gold.extended = extended;
-        surf_gold.upright = upright;
-
         std::vector<cv::KeyPoint> keypoints;
         surf_gold(image, cv::noArray(), keypoints);
 
@@ -303,11 +330,6 @@ TEST_P(SURF, Descriptor)
 
         EXPECT_GT(matchedRatio, 0.6);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
@@ -342,14 +364,26 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
 
 TEST_P(FAST, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-        cv::gpu::FAST_GPU fast(threshold);
-        fast.nonmaxSupression = nonmaxSupression;
+    cv::gpu::FAST_GPU fast(threshold);
+    fast.nonmaxSupression = nonmaxSupression;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -358,11 +392,6 @@ TEST_P(FAST, Accuracy)
 
         ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
@@ -416,17 +445,30 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
 
 TEST_P(ORB, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
 
-        cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
-        orb.blurForDescriptor = blurForDescriptor;
+    cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
+    orb.blurForDescriptor = blurForDescriptor;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            orb(loadMat(image), loadMat(mask), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         cv::gpu::GpuMat descriptors;
         orb(loadMat(image), loadMat(mask), keypoints, descriptors);
@@ -446,11 +488,6 @@ TEST_P(ORB, Accuracy)
 
         EXPECT_GT(matchedRatio, 0.35);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB,  testing::Combine(
@@ -533,416 +570,372 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
 
 TEST_P(BruteForceMatcher, Match_Single)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        cv::gpu::GpuMat mask;
-        if (useMask)
-        {
-            mask.create(query.rows, train.rows, CV_8UC1);
-            mask.setTo(cv::Scalar::all(1));
-        }
-
-        std::vector<cv::DMatch> matches;
-        matcher.match(loadMat(query), loadMat(train), matches, mask);
+    cv::gpu::GpuMat mask;
+    if (useMask)
+    {
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
+    }
 
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+    std::vector<cv::DMatch> matches;
+    matcher.match(loadMat(query), loadMat(train), matches, mask);
 
-        int badCount = 0;
-        for (size_t i = 0; i < matches.size(); i++)
-        {
-            cv::DMatch match = matches[i];
-            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
-                badCount++;
-        }
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::DMatch match = matches[i];
+        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
+            badCount++;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, Match_Collection)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    cv::gpu::GpuMat d_train(train);
+
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount/2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
+
+    std::vector<cv::DMatch> matches;
+    if (useMask)
+        matcher.match(cv::gpu::GpuMat(query), matches, masks);
+    else
+        matcher.match(cv::gpu::GpuMat(query), matches);
 
-        cv::gpu::GpuMat d_train(train);
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        cv::DMatch match = matches[i];
 
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++)
+        if ((int)i < queryDescCount / 2)
         {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount/2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+            bool validQueryIdx = (match.queryIdx == (int)i);
+            bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
+            bool validImgIdx = (match.imgIdx == 0);
+            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                badCount++;
         }
-
-        std::vector<cv::DMatch> matches;
-        if (useMask)
-            matcher.match(cv::gpu::GpuMat(query), matches, masks);
         else
-            matcher.match(cv::gpu::GpuMat(query), matches);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
         {
-            cv::DMatch match = matches[i];
-
-            if ((int)i < queryDescCount / 2)
-            {
-                bool validQueryIdx = (match.queryIdx == (int)i);
-                bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
-                bool validImgIdx = (match.imgIdx == 0);
-                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                    badCount++;
-            }
-            else
-            {
-                bool validQueryIdx = (match.queryIdx == (int)i);
-                bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
-                bool validImgIdx = (match.imgIdx == 1);
-                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                    badCount++;
-            }
+            bool validQueryIdx = (match.queryIdx == (int)i);
+            bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
+            bool validImgIdx = (match.imgIdx == 1);
+            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                badCount++;
         }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const int knn = 2;
+    const int knn = 2;
 
-        cv::gpu::GpuMat mask;
-        if (useMask)
-        {
-            mask.create(query.rows, train.rows, CV_8UC1);
-            mask.setTo(cv::Scalar::all(1));
-        }
+    cv::gpu::GpuMat mask;
+    if (useMask)
+    {
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
+    }
 
-        std::vector< std::vector<cv::DMatch> > matches;
-        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+    std::vector< std::vector<cv::DMatch> > matches;
+    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
 
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        int badCount = 0;
-        for (size_t i = 0; i < matches.size(); i++)
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
         {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                        localBadCount++;
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
+                cv::DMatch match = matches[i][k];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                    localBadCount++;
             }
+            badCount += localBadCount > 0 ? 1 : 0;
         }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_3_Single)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const int knn = 3;
+    const int knn = 3;
 
-        cv::gpu::GpuMat mask;
-        if (useMask)
-        {
-            mask.create(query.rows, train.rows, CV_8UC1);
-            mask.setTo(cv::Scalar::all(1));
-        }
+    cv::gpu::GpuMat mask;
+    if (useMask)
+    {
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
+    }
 
-        std::vector< std::vector<cv::DMatch> > matches;
-        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+    std::vector< std::vector<cv::DMatch> > matches;
+    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
 
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        int badCount = 0;
-        for (size_t i = 0; i < matches.size(); i++)
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
         {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                        localBadCount++;
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
+                cv::DMatch match = matches[i][k];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                    localBadCount++;
             }
+            badCount += localBadCount > 0 ? 1 : 0;
         }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const int knn = 2;
+    const int knn = 2;
 
-        cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_train(train);
 
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
 
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-        }
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++ )
+    {
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
 
-        std::vector< std::vector<cv::DMatch> > matches;
+    std::vector< std::vector<cv::DMatch> > matches;
 
-        if (useMask)
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-        else
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+    if (useMask)
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+    else
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
 
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
         {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
+                cv::DMatch match = matches[i][k];
                 {
-                    cv::DMatch match = matches[i][k];
+                    if ((int)i < queryDescCount / 2)
                     {
-                        if ((int)i < queryDescCount / 2)
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                                localBadCount++;
-                        }
-                        else
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                                localBadCount++;
-                        }
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
                     }
                 }
-                badCount += localBadCount > 0 ? 1 : 0;
             }
+            badCount += localBadCount > 0 ? 1 : 0;
         }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const int knn = 3;
+    const int knn = 3;
 
-        cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_train(train);
 
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
 
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-        }
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++ )
+    {
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
 
-        std::vector< std::vector<cv::DMatch> > matches;
+    std::vector< std::vector<cv::DMatch> > matches;
 
-        if (useMask)
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-        else
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+    if (useMask)
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+    else
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
 
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
         {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
+                cv::DMatch match = matches[i][k];
                 {
-                    cv::DMatch match = matches[i][k];
+                    if ((int)i < queryDescCount / 2)
                     {
-                        if ((int)i < queryDescCount / 2)
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                                localBadCount++;
-                        }
-                        else
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                                localBadCount++;
-                        }
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
                     }
                 }
-                badCount += localBadCount > 0 ? 1 : 0;
             }
+            badCount += localBadCount > 0 ? 1 : 0;
         }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Single)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const float radius = 1.f / countFactor;
+    const float radius = 1.f / countFactor;
 
-        if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
         {
-            try
-            {
-                std::vector< std::vector<cv::DMatch> > matches;
-                matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat mask;
-            if (useMask)
-            {
-                mask.create(query.rows, train.rows, CV_8UC1);
-                mask.setTo(cv::Scalar::all(1));
-            }
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat mask;
+        if (useMask)
+        {
+            mask.create(query.rows, train.rows, CV_8UC1);
+            mask.setTo(cv::Scalar::all(1));
+        }
 
-            std::vector< std::vector<cv::DMatch> > matches;
-            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
+        std::vector< std::vector<cv::DMatch> > matches;
+        matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
 
-            ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-            int badCount = 0;
-            for (size_t i = 0; i < matches.size(); i++)
+        int badCount = 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            if ((int)matches[i].size() != 1)
+                badCount++;
+            else
             {
-                if ((int)matches[i].size() != 1)
+                cv::DMatch match = matches[i][0];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
                     badCount++;
-                else
-                {
-                    cv::DMatch match = matches[i][0];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
-                        badCount++;
-                }
             }
-
-            ASSERT_EQ(0, badCount);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        ASSERT_EQ(0, badCount);
     }
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+    cv::gpu::BFMatcher_GPU matcher(normCode);
 
-        const int n = 3;
-        const float radius = 1.f / countFactor * n;
+    const int n = 3;
+    const float radius = 1.f / countFactor * n;
 
-        cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_train(train);
 
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
 
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++)
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++)
+    {
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
         {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
         }
-
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector< std::vector<cv::DMatch> > matches;
 
         if (useMask)
@@ -984,11 +977,6 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 
         ASSERT_EQ(0, badCount);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 4bdda91..92d6fc0 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -88,23 +88,15 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
 
 TEST_P(Blur, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
 
-        cv::Mat dst_gold;
-        cv::blur(src, dst_gold, ksize, anchor);
+    cv::Mat dst_gold;
+    cv::blur(src, dst_gold, ksize, anchor);
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
@@ -158,23 +150,15 @@ TEST_P(Sobel, Accuracy)
     if (dx == 0 && dy == 0)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
 
-        cv::Mat dst_gold;
-        cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
+    cv::Mat dst_gold;
+    cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
@@ -229,23 +213,15 @@ TEST_P(Scharr, Accuracy)
     if (dx + dy != 1)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
 
-        cv::Mat dst_gold;
-        cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
+    cv::Mat dst_gold;
+    cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
@@ -294,39 +270,31 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
 
 TEST_P(GaussianBlur, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        double sigma1 = randomDouble(0.1, 1.0);
-        double sigma2 = randomDouble(0.1, 1.0);
+    cv::Mat src = randomMat(size, type);
+    double sigma1 = randomDouble(0.1, 1.0);
+    double sigma2 = randomDouble(0.1, 1.0);
 
-        if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+    if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-            cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
-
-            cv::Mat dst_gold;
-            cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
+
+        cv::Mat dst_gold;
+        cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
     }
 }
 
@@ -381,23 +349,15 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
 
 TEST_P(Laplacian, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
 
-        cv::Mat dst_gold;
-        cv::Laplacian(src, dst_gold, -1, ksize.width);
+    cv::Mat dst_gold;
+    cv::Laplacian(src, dst_gold, -1, ksize.width);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
@@ -436,26 +396,18 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
 
 TEST_P(Erode, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::erode(src, dst_gold, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::erode(src, dst_gold, kernel, anchor, iterations);
 
-        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
@@ -493,26 +445,18 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
 
 TEST_P(Dilate, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::dilate(src, dst_gold, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::dilate(src, dst_gold, kernel, anchor, iterations);
 
-        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
@@ -555,26 +499,18 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
 
 TEST_P(MorphEx, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
 
-        cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
+    cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
@@ -617,24 +553,16 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
 
 TEST_P(Filter2D, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
 
-        cv::Mat dst_gold;
-        cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
+    cv::Mat dst_gold;
+    cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
diff --git a/modules/gpu/test/test_global_motion.cpp b/modules/gpu/test/test_global_motion.cpp
index 2b5eab8..b37d080 100644
--- a/modules/gpu/test/test_global_motion.cpp
+++ b/modules/gpu/test/test_global_motion.cpp
@@ -53,43 +53,35 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
 
 TEST_P(CompactPoints, CanCompactizeSmallInput)
 {
-    try
-    {
-        Mat src0(1, 3, CV_32FC2);
-        src0.at<Point2f>(0,0) = Point2f(0,0);
-        src0.at<Point2f>(0,1) = Point2f(0,1);
-        src0.at<Point2f>(0,2) = Point2f(0,2);
+    Mat src0(1, 3, CV_32FC2);
+    src0.at<Point2f>(0,0) = Point2f(0,0);
+    src0.at<Point2f>(0,1) = Point2f(0,1);
+    src0.at<Point2f>(0,2) = Point2f(0,2);
 
-        Mat src1(1, 3, CV_32FC2);
-        src1.at<Point2f>(0,0) = Point2f(1,0);
-        src1.at<Point2f>(0,1) = Point2f(1,1);
-        src1.at<Point2f>(0,2) = Point2f(1,2);
+    Mat src1(1, 3, CV_32FC2);
+    src1.at<Point2f>(0,0) = Point2f(1,0);
+    src1.at<Point2f>(0,1) = Point2f(1,1);
+    src1.at<Point2f>(0,2) = Point2f(1,2);
 
-        Mat mask(1, 3, CV_8U);
-        mask.at<uchar>(0,0) = 1;
-        mask.at<uchar>(0,1) = 0;
-        mask.at<uchar>(0,2) = 1;
+    Mat mask(1, 3, CV_8U);
+    mask.at<uchar>(0,0) = 1;
+    mask.at<uchar>(0,1) = 0;
+    mask.at<uchar>(0,2) = 1;
 
-        gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
-        gpu::compactPoints(dsrc0, dsrc1, dmask);
+    gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
+    gpu::compactPoints(dsrc0, dsrc1, dmask);
 
-        dsrc0.download(src0);
-        dsrc1.download(src1);
+    dsrc0.download(src0);
+    dsrc1.download(src1);
 
-        ASSERT_EQ(2, src0.cols);
-        ASSERT_EQ(2, src1.cols);
+    ASSERT_EQ(2, src0.cols);
+    ASSERT_EQ(2, src1.cols);
 
-        ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
-        ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
+    ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
+    ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
 
-        ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
-        ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
+    ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp
index fed9540..9d7e545 100644
--- a/modules/gpu/test/test_gpumat.cpp
+++ b/modules/gpu/test/test_gpumat.cpp
@@ -69,122 +69,90 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(SetTo, Zero)
 {
-    try
-    {
-        cv::Scalar zero = cv::Scalar::all(0);
+    cv::Scalar zero = cv::Scalar::all(0);
 
-        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-        mat.setTo(zero);
+    cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+    mat.setTo(zero);
 
-        EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
 }
 
 TEST_P(SetTo, SameVal)
 {
-    try
-    {
-        cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
+    cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-
-            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
 }
 
 TEST_P(SetTo, DifferentVal)
 {
-    try
-    {
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-
-            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
 }
 
 TEST_P(SetTo, Masked)
 {
-    try
-    {
-        cv::Scalar val = randomScalar(0.0, 255.0);
-        cv::Mat mat_gold = randomMat(size, type);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat mat_gold = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+            mat.setTo(val, loadMat(mask));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
-            mat.setTo(val, loadMat(mask, useRoi));
-
-            mat_gold.setTo(val, mask);
-
-            EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
+        mat.setTo(val, loadMat(mask, useRoi));
+
+        mat_gold.setTo(val, mask);
+
+        EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
     }
 }
 
@@ -218,59 +186,43 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(CopyTo, WithOutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        d_src.copyTo(dst);
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    d_src.copyTo(dst);
 
-        EXPECT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(src, dst, 0.0);
 }
 
 TEST_P(CopyTo, Masked)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.copyTo(dst, loadMat(mask, useRoi));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.copyTo(dst, loadMat(mask, useRoi));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
-            d_src.copyTo(dst, loadMat(mask, useRoi));
-
-            cv::Mat dst_gold = cv::Mat::zeros(size, type);
-            src.copyTo(dst_gold, mask);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+        d_src.copyTo(dst, loadMat(mask, useRoi));
+
+        cv::Mat dst_gold = cv::Mat::zeros(size, type);
+        src.copyTo(dst_gold, mask);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -305,79 +257,63 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
 
 TEST_P(ConvertTo, WithOutScaling)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth1);
+    cv::Mat src = randomMat(size, depth1);
 
-        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.convertTo(dst, depth2);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.convertTo(dst, depth2);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
-            d_src.convertTo(dst, depth2);
-
-            cv::Mat dst_gold;
-            src.convertTo(dst_gold, depth2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(ConvertTo, WithScaling)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth1);
-        double a = randomDouble(0.0, 1.0);
-        double b = randomDouble(-10.0, 10.0);
+    cv::Mat src = randomMat(size, depth1);
+    double a = randomDouble(0.0, 1.0);
+    double b = randomDouble(-10.0, 10.0);
 
-        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.convertTo(dst, depth2, a, b);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
+            d_src.convertTo(dst, depth2, a, b);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
-            d_src.convertTo(dst, depth2, a, b);
-
-            cv::Mat dst_gold;
-            src.convertTo(dst_gold, depth2, a, b);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2, a, b);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2, a, b);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
     }
 }
 
@@ -402,30 +338,22 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(EnsureSizeIsEnough, BufferReuse)
 {
-    try
-    {
-        cv::gpu::GpuMat buffer(100, 100, CV_8U);
-        cv::gpu::GpuMat old = buffer;
-
-        // don't reallocate memory
-        cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
-        EXPECT_EQ(10, buffer.rows);
-        EXPECT_EQ(20, buffer.cols);
-        EXPECT_EQ(CV_8UC1, buffer.type());
-        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
-
-        // don't reallocate memory
-        cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
-        EXPECT_EQ(20, buffer.rows);
-        EXPECT_EQ(30, buffer.cols);
-        EXPECT_EQ(CV_8UC1, buffer.type());
-        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::gpu::GpuMat buffer(100, 100, CV_8U);
+    cv::gpu::GpuMat old = buffer;
+
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
+    EXPECT_EQ(10, buffer.rows);
+    EXPECT_EQ(20, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
+    EXPECT_EQ(20, buffer.rows);
+    EXPECT_EQ(30, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp
index 76ed0c6..c418d6a 100644
--- a/modules/gpu/test/test_hough.cpp
+++ b/modules/gpu/test/test_hough.cpp
@@ -81,36 +81,28 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughLines, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const bool useRoi = GET_PARAM(2);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(2);
 
-        const float rho = 1.0f;
-        const float theta = (float) (1.5 * CV_PI / 180.0);
-        const int threshold = 100;
+    const float rho = 1.0f;
+    const float theta = (float) (1.5 * CV_PI / 180.0);
+    onst int threshold = 100;
 
-        cv::Mat src(size, CV_8UC1);
-        generateLines(src);
+    cv::Mat src(size, CV_8UC1);
+    generateLines(src);
 
-        cv::gpu::GpuMat d_lines;
-        cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
+    cv::gpu::GpuMat d_lines;
+    cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
 
-        std::vector<cv::Vec2f> lines;
-        cv::gpu::HoughLinesDownload(d_lines, lines);
+    std::vector<cv::Vec2f> lines;
+    cv::gpu::HoughLinesDownload(d_lines, lines);
 
-        cv::Mat dst(size, CV_8UC1);
-        drawLines(dst, lines);
+    cv::Mat dst(size, CV_8UC1);
+    drawLines(dst, lines);
 
-        ASSERT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_MAT_NEAR(src, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
@@ -134,61 +126,53 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughCircles, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const bool useRoi = GET_PARAM(2);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(2);
 
-        const float dp = 2.0f;
-        const float minDist = 10.0f;
-        const int minRadius = 10;
-        const int maxRadius = 20;
-        const int cannyThreshold = 100;
-        const int votesThreshold = 20;
+    const float dp = 2.0f;
+    const float minDist = 10.0f;
+    const int minRadius = 10;
+    const int maxRadius = 20;
+    const int cannyThreshold = 100;
+    const int votesThreshold = 20;
 
-        std::vector<cv::Vec3f> circles_gold(4);
-        circles_gold[0] = cv::Vec3i(20, 20, minRadius);
-        circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
-        circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
-        circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
+    std::vector<cv::Vec3f> circles_gold(4);
+    circles_gold[0] = cv::Vec3i(20, 20, minRadius);
+    circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
+    circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
+    circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
 
-        cv::Mat src(size, CV_8UC1);
-        drawCircles(src, circles_gold, true);
+    cv::Mat src(size, CV_8UC1);
+    drawCircles(src, circles_gold, true);
 
-        cv::gpu::GpuMat d_circles;
-        cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+    cv::gpu::GpuMat d_circles;
+    cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
 
-        std::vector<cv::Vec3f> circles;
-        cv::gpu::HoughCirclesDownload(d_circles, circles);
+    std::vector<cv::Vec3f> circles;
+    cv::gpu::HoughCirclesDownload(d_circles, circles);
 
-        ASSERT_FALSE(circles.empty());
+    ASSERT_FALSE(circles.empty());
 
-        for (size_t i = 0; i < circles.size(); ++i)
-        {
-            cv::Vec3f cur = circles[i];
+    for (size_t i = 0; i < circles.size(); ++i)
+    {
+        cv::Vec3f cur = circles[i];
 
-            bool found = false;
+        bool found = false;
 
-            for (size_t j = 0; j < circles_gold.size(); ++j)
-            {
-                cv::Vec3f gold = circles_gold[j];
+        for (size_t j = 0; j < circles_gold.size(); ++j)
+        {
+            cv::Vec3f gold = circles_gold[j];
 
-                if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
-                {
-                    found = true;
-                    break;
-                }
+            if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
+            {
+                found = true;
+                break;
             }
-
-            ASSERT_TRUE(found);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        ASSERT_TRUE(found);
     }
 }
 
@@ -206,68 +190,60 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(GeneralizedHough, POSITION)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const bool useRoi = GET_PARAM(1);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const bool useRoi = GET_PARAM(1);
 
-        cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(templ.empty());
+    cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(templ.empty());
 
-        cv::Point templCenter(templ.cols / 2, templ.rows / 2);
+    cv::Point templCenter(templ.cols / 2, templ.rows / 2);
 
-        const size_t gold_count = 3;
-        cv::Point pos_gold[gold_count];
-        pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
-        pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
-        pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
+    const size_t gold_count = 3;
+    cv::Point pos_gold[gold_count];
+    pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
+    pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
+    pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
 
-        cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
-        for (size_t i = 0; i < gold_count; ++i)
-        {
-            cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
-            cv::Mat imageROI = image(rec);
-            templ.copyTo(imageROI);
-        }
+    cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
+    for (size_t i = 0; i < gold_count; ++i)
+    {
+        cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
+        cv::Mat imageROI = image(rec);
+        templ.copyTo(imageROI);
+    }
 
-        cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
-        hough->set("votesThreshold", 200);
+    cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
+    hough->set("votesThreshold", 200);
 
-        hough->setTemplate(loadMat(templ, useRoi));
+    hough->setTemplate(loadMat(templ, useRoi));
 
-        cv::gpu::GpuMat d_pos;
-        hough->detect(loadMat(image, useRoi), d_pos);
+    cv::gpu::GpuMat d_pos;
+    hough->detect(loadMat(image, useRoi), d_pos);
 
-        std::vector<cv::Vec4f> pos;
-        hough->download(d_pos, pos);
+    std::vector<cv::Vec4f> pos;
+    hough->download(d_pos, pos);
 
-        ASSERT_EQ(gold_count, pos.size());
+    ASSERT_EQ(gold_count, pos.size());
 
-        for (size_t i = 0; i < gold_count; ++i)
-        {
-            cv::Point gold = pos_gold[i];
+    for (size_t i = 0; i < gold_count; ++i)
+    {
+        cv::Point gold = pos_gold[i];
 
-            bool found = false;
+        bool found = false;
 
-            for (size_t j = 0; j < pos.size(); ++j)
-            {
-                cv::Point2f p(pos[j][0], pos[j][1]);
+        for (size_t j = 0; j < pos.size(); ++j)
+        {
+            cv::Point2f p(pos[j][0], pos[j][1]);
 
-                if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
-                {
-                    found = true;
-                    break;
-                }
+            if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
+            {
+                found = true;
+                break;
             }
-
-            ASSERT_TRUE(found);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        ASSERT_TRUE(found);
     }
 }
 
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index 9de3808..71d4a8e 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -66,23 +66,15 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Integral, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
-        cv::gpu::integral(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
+    cv::gpu::integral(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::integral(src, dst_gold, CV_32S);
+    cv::Mat dst_gold;
+    cv::integral(src, dst_gold, CV_32S);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
@@ -107,40 +99,32 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(HistEven, Accuracy)
 {
-    try
-    {
-        cv::Mat img = readImage("stereobm/aloe-L.png");
-        ASSERT_FALSE(img.empty());
+    cv::Mat img = readImage("stereobm/aloe-L.png");
+    ASSERT_FALSE(img.empty());
 
-        cv::Mat hsv;
-        cv::cvtColor(img, hsv, CV_BGR2HSV);
+    cv::Mat hsv;
+    cv::cvtColor(img, hsv, CV_BGR2HSV);
 
-        int hbins = 30;
-        float hranges[] = {0.0f, 180.0f};
+    int hbins = 30;
+    float hranges[] = {0.0f, 180.0f};
 
-        std::vector<cv::gpu::GpuMat> srcs;
-        cv::gpu::split(loadMat(hsv), srcs);
+    std::vector<cv::gpu::GpuMat> srcs;
+    cv::gpu::split(loadMat(hsv), srcs);
 
-        cv::gpu::GpuMat hist;
-        cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
+    cv::gpu::GpuMat hist;
+    cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
 
-        cv::MatND histnd;
-        int histSize[] = {hbins};
-        const float* ranges[] = {hranges};
-        int channels[] = {0};
-        cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
+    cv::MatND histnd;
+    int histSize[] = {hbins};
+    const float* ranges[] = {hranges};
+    int channels[] = {0};
+    cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
 
-        cv::Mat hist_gold = histnd;
-        hist_gold = hist_gold.t();
-        hist_gold.convertTo(hist_gold, CV_32S);
+    cv::Mat hist_gold = histnd;
+    hist_gold = hist_gold.t();
+    hist_gold.convertTo(hist_gold, CV_32S);
 
-        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@@ -180,23 +164,15 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(CalcHist, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat hist;
-        cv::gpu::calcHist(loadMat(src), hist);
+    cv::gpu::GpuMat hist;
+    cv::gpu::calcHist(loadMat(src), hist);
 
-        cv::Mat hist_gold;
-        calcHistGold(src, hist_gold);
+    cv::Mat hist_gold;
+    calcHistGold(src, hist_gold);
 
-        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
@@ -222,23 +198,15 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(EqualizeHist, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::equalizeHist(loadMat(src), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::equalizeHist(loadMat(src), dst);
 
-        cv::Mat dst_gold;
-        cv::equalizeHist(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::equalizeHist(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
@@ -264,36 +232,28 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(ColumnSum, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC1);
+    cv::Mat src = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::columnSum(loadMat(src), d_dst);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::columnSum(loadMat(src), d_dst);
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
+
+    for (int j = 0; j < src.cols; ++j)
+    {
+        float gold = src.at<float>(0, j);
+        float res = dst.at<float>(0, j);
+        ASSERT_NEAR(res, gold, 1e-5);
+    }
 
+    for (int i = 1; i < src.rows; ++i)
+    {
         for (int j = 0; j < src.cols; ++j)
         {
-            float gold = src.at<float>(0, j);
-            float res = dst.at<float>(0, j);
+            float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
+            float res = dst.at<float>(i, j);
             ASSERT_NEAR(res, gold, 1e-5);
         }
-
-        for (int i = 1; i < src.rows; ++i)
-        {
-            for (int j = 0; j < src.cols; ++j)
-            {
-                float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
-                float res = dst.at<float>(i, j);
-                ASSERT_NEAR(res, gold, 1e-5);
-            }
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
 }
 
@@ -327,41 +287,33 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
 
 TEST_P(Canny, Accuracy)
 {
-    try
-    {
-        cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(img.empty());
+    cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-        double low_thresh = 50.0;
-        double high_thresh = 100.0;
+    double low_thresh = 50.0;
+    double high_thresh = 100.0;
 
-        if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+    if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+    {
+        try
         {
-            try
-            {
-            cv::gpu::GpuMat edges;
-            cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+        cv::gpu::GpuMat edges;
+        cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat edges;
-            cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-            cv::Mat edges_gold;
-            cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-            EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat edges;
+        cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+        cv::Mat edges_gold;
+        cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+        EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
     }
 }
 
@@ -399,66 +351,50 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(MeanShift, Filtering)
 {
-    try
-    {
-        cv::Mat img_template;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            img_template = readImage("meanshift/con_result.png");
-        else
-            img_template = readImage("meanshift/con_result_CC1X.png");
-        ASSERT_FALSE(img_template.empty());
+    cv::Mat img_template;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        img_template = readImage("meanshift/con_result.png");
+    else
+        img_template = readImage("meanshift/con_result_CC1X.png");
+    ASSERT_FALSE(img_template.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
 
-        ASSERT_EQ(CV_8UC4, d_dst.type());
+    ASSERT_EQ(CV_8UC4, d_dst.type());
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        cv::Mat result;
-        cv::cvtColor(dst, result, CV_BGRA2BGR);
+    cv::Mat result;
+    cv::cvtColor(dst, result, CV_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(img_template, result, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(img_template, result, 0.0);
 }
 
 TEST_P(MeanShift, Proc)
 {
-    try
-    {
-        cv::FileStorage fs;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
-        else
-            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+    else
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        cv::Mat spmap_template;
-        fs["spmap"] >> spmap_template;
-        ASSERT_FALSE(spmap_template.empty());
+    cv::Mat spmap_template;
+    fs["spmap"] >> spmap_template;
+    ASSERT_FALSE(spmap_template.empty());
 
-        cv::gpu::GpuMat rmap_filtered;
-        cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
+    cv::gpu::GpuMat rmap_filtered;
+    cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
 
-        cv::gpu::GpuMat rmap;
-        cv::gpu::GpuMat spmap;
-        cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
+    cv::gpu::GpuMat rmap;
+    cv::gpu::GpuMat spmap;
+    cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
 
-        ASSERT_EQ(CV_8UC4, rmap.type());
+    ASSERT_EQ(CV_8UC4, rmap.type());
 
-        EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
-        EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
+    EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
@@ -484,33 +420,25 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
 
 TEST_P(MeanShiftSegmentation, Regression)
 {
-    try
-    {
-        cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
-        ASSERT_FALSE(img.empty());
+    cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
+    ASSERT_FALSE(img.empty());
 
-        std::ostringstream path;
-        path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            path << ".png";
-        else
-            path << "_CC1X.png";
-        cv::Mat dst_gold = readImage(path.str());
-        ASSERT_FALSE(dst_gold.empty());
+    std::ostringstream path;
+    path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        path << ".png";
+    else
+        path << "_CC1X.png";
+    cv::Mat dst_gold = readImage(path.str());
+    ASSERT_FALSE(dst_gold.empty());
 
-        cv::Mat dst;
-        cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
+    cv::Mat dst;
+    cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
 
-        cv::Mat dst_rgb;
-        cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+    cv::Mat dst_rgb;
+    cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
@@ -564,31 +492,23 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Blend, Accuracy)
 {
-    try
-    {
-        int depth = CV_MAT_DEPTH(type);
+    int depth = CV_MAT_DEPTH(type);
 
-        cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-        cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-        cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
-        cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
+    cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+    cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+    cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
+    cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
 
-        cv::gpu::GpuMat result;
-        cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
+    cv::gpu::GpuMat result;
+    cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
 
-        cv::Mat result_gold;
-        if (depth == CV_8U)
-            blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
-        else
-            blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
+    cv::Mat result_gold;
+    if (depth == CV_8U)
+        blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
+    else
+        blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
 
-        EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
@@ -662,24 +582,16 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
 
 TEST_P(Convolve, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
-        cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
+    cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
+    cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+    cv::gpu::GpuMat dst;
+    cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
 
-        cv::Mat dst_gold;
-        convolveDFT(src, kernel, dst_gold, ccorr);
+    cv::Mat dst_gold;
+    convolveDFT(src, kernel, dst_gold, ccorr);
 
-        EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
@@ -718,24 +630,16 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
 
 TEST_P(MatchTemplate8U, Accuracy)
 {
-    try
-    {
-        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
-        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
+    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
+    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+    cv::gpu::GpuMat dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-        cv::Mat dst_gold;
-        cv::matchTemplate(image, templ, dst_gold, method);
+    cv::Mat dst_gold;
+    cv::matchTemplate(image, templ, dst_gold, method);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
@@ -772,24 +676,16 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
 
 TEST_P(MatchTemplate32F, Regression)
 {
-    try
-    {
-        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
-        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
+    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
+    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+    cv::gpu::GpuMat dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-        cv::Mat dst_gold;
-        cv::matchTemplate(image, templ, dst_gold, method);
+    cv::Mat dst_gold;
+    cv::matchTemplate(image, templ, dst_gold, method);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
@@ -818,32 +714,24 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
 
 TEST_P(MatchTemplateBlackSource, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage("matchtemplate/black.png");
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("matchtemplate/black.png");
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat pattern = readImage("matchtemplate/cat.png");
-        ASSERT_FALSE(pattern.empty());
+    cv::Mat pattern = readImage("matchtemplate/cat.png");
+    ASSERT_FALSE(pattern.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        double maxValue;
-        cv::Point maxLoc;
-        cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
+    double maxValue;
+    cv::Point maxLoc;
+    cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
 
-        cv::Point maxLocGold = cv::Point(284, 12);
+    cv::Point maxLocGold = cv::Point(284, 12);
 
-        ASSERT_EQ(maxLocGold, maxLoc);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(maxLocGold, maxLoc);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
@@ -871,40 +759,32 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
 
 TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage(imageName);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage(imageName);
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat pattern = readImage(patternName);
-        ASSERT_FALSE(pattern.empty());
+    cv::Mat pattern = readImage(patternName);
+    ASSERT_FALSE(pattern.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        cv::Point minLoc, maxLoc;
-        double minVal, maxVal;
-        cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
+    cv::Point minLoc, maxLoc;
+    double minVal, maxVal;
+    cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
 
-        cv::Mat dstGold;
-        cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
+    cv::Mat dstGold;
+    cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
 
-        double minValGold, maxValGold;
-        cv::Point minLocGold, maxLocGold;
-        cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
+    double minValGold, maxValGold;
+    cv::Point minLocGold, maxLocGold;
+    cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
 
-        ASSERT_EQ(minLocGold, minLoc);
-        ASSERT_EQ(maxLocGold, maxLoc);
-        ASSERT_LE(maxVal, 1.0);
-        ASSERT_GE(minVal, -1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(minLocGold, minLoc);
+    ASSERT_EQ(maxLocGold, maxLoc);
+    ASSERT_LE(maxVal, 1.0);
+    ASSERT_GE(minVal, -1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
@@ -928,63 +808,47 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
 {
-    try
-    {
-        cv::Mat scene = readImage("matchtemplate/scene.png");
-        ASSERT_FALSE(scene.empty());
+    cv::Mat scene = readImage("matchtemplate/scene.png");
+    ASSERT_FALSE(scene.empty());
 
-        cv::Mat templ = readImage("matchtemplate/template.png");
-        ASSERT_FALSE(templ.empty());
+    cv::Mat templ = readImage("matchtemplate/template.png");
+    ASSERT_FALSE(templ.empty());
 
-        cv::gpu::GpuMat d_result;
-        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
+    cv::gpu::GpuMat d_result;
+    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
 
-        cv::Mat result(d_result);
+    cv::Mat result(d_result);
 
-        double minVal;
-        cv::Point minLoc;
-        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+    double minVal;
+    cv::Point minLoc;
+    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-        ASSERT_GE(minVal, 0);
-        ASSERT_LT(minVal, 1e-3);
-        ASSERT_EQ(344, minLoc.x);
-        ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_GE(minVal, 0);
+    ASSERT_LT(minVal, 1e-3);
+    ASSERT_EQ(344, minLoc.x);
+    ASSERT_EQ(0, minLoc.y);
 }
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
 {
-    try
-    {
-        cv::Mat scene = readImage("matchtemplate/scene.png");
-        ASSERT_FALSE(scene.empty());
+    cv::Mat scene = readImage("matchtemplate/scene.png");
+    ASSERT_FALSE(scene.empty());
 
-        cv::Mat templ = readImage("matchtemplate/template.png");
-        ASSERT_FALSE(templ.empty());
+    cv::Mat templ = readImage("matchtemplate/template.png");
+    ASSERT_FALSE(templ.empty());
 
-        cv::gpu::GpuMat d_result;
-        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
+    cv::gpu::GpuMat d_result;
+    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
 
-        cv::Mat result(d_result);
+    cv::Mat result(d_result);
 
-        double minVal;
-        cv::Point minLoc;
-        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+    double minVal;
+    cv::Point minLoc;
+    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-        ASSERT_GE(minVal, 0);
-        ASSERT_EQ(344, minLoc.x);
-        ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_GE(minVal, 0);
+    ASSERT_EQ(344, minLoc.x);
+    ASSERT_EQ(0, minLoc.y);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
@@ -1017,43 +881,27 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
 
 TEST_P(MulSpectrums, Simple)
 {
-    try
-    {
-        cv::gpu::GpuMat c;
-        cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
+    cv::gpu::GpuMat c;
+    cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
 
-        cv::Mat c_gold;
-        cv::mulSpectrums(a, b, c_gold, flag, false);
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
 
-        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
 }
 
 TEST_P(MulSpectrums, Scaled)
 {
-    try
-    {
-        float scale = 1.f / size.area();
+    float scale = 1.f / size.area();
 
-        cv::gpu::GpuMat c;
-        cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
+    cv::gpu::GpuMat c;
+    cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
 
-        cv::Mat c_gold;
-        cv::mulSpectrums(a, b, c_gold, flag, false);
-        c_gold.convertTo(c_gold, c_gold.type(), scale);
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
+    c_gold.convertTo(c_gold, c_gold.type(), scale);
 
-        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
@@ -1102,34 +950,26 @@ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplac
 
 TEST_P(Dft, C2C)
 {
-    try
-    {
-        int cols = randomInt(2, 100);
-        int rows = randomInt(2, 100);
-
-        for (int i = 0; i < 2; ++i)
-        {
-            bool inplace = i != 0;
-
-            testC2C("no flags", cols, rows, 0, inplace);
-            testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
-            testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
-            testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
-            testC2C("single col", 1, rows, 0, inplace);
-            testC2C("single row", cols, 1, 0, inplace);
-            testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
-            testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
-            testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
-            testC2C("size 1 2", 1, 2, 0, inplace);
-            testC2C("size 2 1", 2, 1, 0, inplace);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+    int cols = randomInt(2, 100);
+    int rows = randomInt(2, 100);
+
+    for (int i = 0; i < 2; ++i)
+    {
+        bool inplace = i != 0;
+
+        testC2C("no flags", cols, rows, 0, inplace);
+        testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+        testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+        testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+        testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+        testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+        testC2C("single col", 1, rows, 0, inplace);
+        testC2C("single row", cols, 1, 0, inplace);
+        testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+        testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+        testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+        testC2C("size 1 2", 1, 2, 0, inplace);
+        testC2C("size 2 1", 2, 1, 0, inplace);
     }
 }
 
@@ -1171,32 +1011,24 @@ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
 
 TEST_P(Dft, R2CThenC2R)
 {
-    try
-    {
-        int cols = randomInt(2, 100);
-        int rows = randomInt(2, 100);
-
-        testR2CThenC2R("sanity", cols, rows, false);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
-        testR2CThenC2R("single col", 1, rows, false);
-        testR2CThenC2R("single col 1", 1, rows + 1, false);
-        testR2CThenC2R("single row", cols, 1, false);
-        testR2CThenC2R("single row 1", cols + 1, 1, false);
-
-        testR2CThenC2R("sanity", cols, rows, true);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
-        testR2CThenC2R("single row", cols, 1, true);
-        testR2CThenC2R("single row 1", cols + 1, 1, true);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    int cols = randomInt(2, 100);
+    int rows = randomInt(2, 100);
+
+    testR2CThenC2R("sanity", cols, rows, false);
+    testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+    testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+    testR2CThenC2R("single col", 1, rows, false);
+    testR2CThenC2R("single col 1", 1, rows + 1, false);
+    testR2CThenC2R("single row", cols, 1, false);
+    testR2CThenC2R("single row 1", cols + 1, 1, false);
+
+    testR2CThenC2R("sanity", cols, rows, true);
+    testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+    testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+    testR2CThenC2R("single row", cols, 1, true);
+    testR2CThenC2R("single row 1", cols + 1, 1, true);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
@@ -1229,26 +1061,18 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
 
 TEST_P(CornerHarris, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        double k = randomDouble(0.1, 0.9);
+    double k = randomDouble(0.1, 0.9);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
 
-        cv::Mat dst_gold;
-        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
+    cv::Mat dst_gold;
+    cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
@@ -1283,24 +1107,16 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
 
 TEST_P(CornerMinEigen, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
 
-        cv::Mat dst_gold;
-        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
+    cv::Mat dst_gold;
+    cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
diff --git a/modules/gpu/test/test_labeling.cpp b/modules/gpu/test/test_labeling.cpp
index 21ee03b..68d2cf4 100644
--- a/modules/gpu/test/test_labeling.cpp
+++ b/modules/gpu/test/test_labeling.cpp
@@ -168,35 +168,27 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(Labeling, ConnectedComponents)
 {
-    try
-    {
-        cv::Mat image;
-        cvtColor(loat_image(), image, CV_BGR2GRAY);
+    cv::Mat image;
+    cvtColor(loat_image(), image, CV_BGR2GRAY);
 
-        cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+    cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
 
-        ASSERT_TRUE(image.type() == CV_8UC1);
+    ASSERT_TRUE(image.type() == CV_8UC1);
 
-        GreedyLabeling host(image);
-        host(host._labels);
+    GreedyLabeling host(image);
+    host(host._labels);
 
-        cv::gpu::GpuMat mask;
-        mask.create(image.rows, image.cols, CV_8UC1);
+    cv::gpu::GpuMat mask;
+    mask.create(image.rows, image.cols, CV_8UC1);
 
-        cv::gpu::GpuMat components;
-        components.create(image.rows, image.cols, CV_32SC1);
+    cv::gpu::GpuMat components;
+    components.create(image.rows, image.cols, CV_32SC1);
 
-        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+    cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
 
-        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+    ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
 
-        host.checkCorrectness(cv::Mat(components));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    host.checkCorrectness(cv::Mat(components));
 }
 
 INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);
diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp
index 0b844d3..484f3cf 100644
--- a/modules/gpu/test/test_nvidia.cpp
+++ b/modules/gpu/test/test_nvidia.cpp
@@ -69,169 +69,82 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
 struct NPPST : NVidiaTest {};
 struct NCV : NVidiaTest {};
 
-TEST_P(NPPST, Integral)
-{
-    try
-    {
-        bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
+//TEST_P(NPPST, Integral)
+//{
+//    bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
-}
+//    ASSERT_TRUE(res);
+//}
 
 TEST_P(NPPST, SquaredIntegral)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, RectStdDev)
 {
-    try
-    {
-        bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Resize)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, VectorOperations)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Transpose)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, VectorOperations)
 {
-    try
-    {
-        bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeLoader)
 {
-    try
-    {
-        bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeApplication)
 {
-    try
-    {
-        bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HypothesesFiltration)
 {
-    try
-    {
-        bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, Visualization)
 {
-    try
-    {
-        bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
+    // this functionality doesn't used in gpu module
+    bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
diff --git a/modules/gpu/test/test_objdetect.cpp b/modules/gpu/test/test_objdetect.cpp
index 81c6c40..4fb295d 100644
--- a/modules/gpu/test/test_objdetect.cpp
+++ b/modules/gpu/test/test_objdetect.cpp
@@ -175,129 +175,114 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
     }
 };
 
-TEST_P(HOG, Detect)
+// desabled while resize does not fixed
+TEST_P(HOG, DISABLED_Detect)
 {
-    try
-    {
-        cv::Mat img_rgb = readImage("hog/road.png");
-        ASSERT_FALSE(img_rgb.empty());
-
-    #ifdef DUMP
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
-    #else
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
-    #endif
-
-        // Test on color image
-        cv::Mat img;
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        testDetect(img);
-
-        // Test on gray image
-        cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
-        testDetect(img);
-
-        f.close();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::Mat img_rgb = readImage("hog/road.png");
+    ASSERT_FALSE(img_rgb.empty());
+
+#ifdef DUMP
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#else
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#endif
+
+    // Test on color image
+    cv::Mat img;
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    testDetect(img);
+
+    // Test on gray image
+    cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+    testDetect(img);
+
+    f.close();
 }
 
 TEST_P(HOG, GetDescriptors)
 {
-    try
-    {
-        // Load image (e.g. train data, composed from windows)
-        cv::Mat img_rgb = readImage("hog/train_data.png");
-        ASSERT_FALSE(img_rgb.empty());
-
-        // Convert to C4
-        cv::Mat img;
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-
-        cv::gpu::GpuMat d_img(img);
-
-        // Convert train images into feature vectors (train table)
-        cv::gpu::GpuMat descriptors, descriptors_by_cols;
-        getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
-        getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
-
-        // Check size of the result train table
-        wins_per_img_x = 3;
-        wins_per_img_y = 2;
-        blocks_per_win_x = 7;
-        blocks_per_win_y = 15;
-        block_hist_size = 36;
-        cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
-                                                wins_per_img_x * wins_per_img_y);
-        ASSERT_EQ(descr_size_expected, descriptors.size());
-
-        // Check both formats of output descriptors are handled correctly
-        cv::Mat dr(descriptors);
-        cv::Mat dc(descriptors_by_cols);
-        for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
-        {
-            const float* l = dr.rowRange(i, i + 1).ptr<float>();
-            const float* r = dc.rowRange(i, i + 1).ptr<float>();
-            for (int y = 0; y < blocks_per_win_y; ++y)
-                for (int x = 0; x < blocks_per_win_x; ++x)
-                    for (int k = 0; k < block_hist_size; ++k)
-                        ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
-                                  r[(x * blocks_per_win_y + y) * block_hist_size + k]);
-        }
+    // Load image (e.g. train data, composed from windows)
+    cv::Mat img_rgb = readImage("hog/train_data.png");
+    ASSERT_FALSE(img_rgb.empty());
 
-        /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
-        be defferent, due to border values interpolation. Using of many small images is slower, however we
-        wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
-        works good, it can be checked in the gpu_hog sample */
-
-        img_rgb = readImage("hog/positive1.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        // Everything is fine with interpolation for left top subimage
-        ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
-
-        img_rgb = readImage("hog/positive2.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
-
-        img_rgb = readImage("hog/negative1.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
-
-        img_rgb = readImage("hog/negative2.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
-
-        img_rgb = readImage("hog/positive3.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
-
-        img_rgb = readImage("hog/negative3.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
-    }
-    catch (...)
+    // Convert to C4
+    cv::Mat img;
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+
+    cv::gpu::GpuMat d_img(img);
+
+    // Convert train images into feature vectors (train table)
+    cv::gpu::GpuMat descriptors, descriptors_by_cols;
+    getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
+    getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
+
+    // Check size of the result train table
+    wins_per_img_x = 3;
+    wins_per_img_y = 2;
+    blocks_per_win_x = 7;
+    blocks_per_win_y = 15;
+    block_hist_size = 36;
+    cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
+                                            wins_per_img_x * wins_per_img_y);
+    ASSERT_EQ(descr_size_expected, descriptors.size());
+
+    // Check both formats of output descriptors are handled correctly
+    cv::Mat dr(descriptors);
+    cv::Mat dc(descriptors_by_cols);
+    for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        const float* l = dr.rowRange(i, i + 1).ptr<float>();
+        const float* r = dc.rowRange(i, i + 1).ptr<float>();
+        for (int y = 0; y < blocks_per_win_y; ++y)
+            for (int x = 0; x < blocks_per_win_x; ++x)
+                for (int k = 0; k < block_hist_size; ++k)
+                    ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
+                              r[(x * blocks_per_win_y + y) * block_hist_size + k]);
     }
+
+    /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
+    be defferent, due to border values interpolation. Using of many small images is slower, however we
+    wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
+    works good, it can be checked in the gpu_hog sample */
+
+    img_rgb = readImage("hog/positive1.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    // Everything is fine with interpolation for left top subimage
+    ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
+
+    img_rgb = readImage("hog/positive2.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
+
+    img_rgb = readImage("hog/negative1.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
+
+    img_rgb = readImage("hog/negative2.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
+
+    img_rgb = readImage("hog/positive3.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
+
+    img_rgb = readImage("hog/negative3.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
@@ -320,35 +305,27 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
 
 TEST_P(CalTech, HOG)
 {
-    try
-    {
-        cv::gpu::GpuMat d_img(img);
-        cv::Mat markedImage(img.clone());
-
-        cv::gpu::HOGDescriptor d_hog;
-        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-        d_hog.nlevels = d_hog.nlevels + 32;
+    cv::gpu::GpuMat d_img(img);
+    cv::Mat markedImage(img.clone());
 
-        std::vector<cv::Rect> found_locations;
-        d_hog.detectMultiScale(d_img, found_locations);
+    cv::gpu::HOGDescriptor d_hog;
+    d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+    d_hog.nlevels = d_hog.nlevels + 32;
 
-    #if defined (LOG_CASCADE_STATISTIC)
-        for (int i = 0; i < (int)found_locations.size(); i++)
-        {
-            cv::Rect r = found_locations[i];
-
-            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
-        }
+    std::vector<cv::Rect> found_locations;
+    d_hog.detectMultiScale(d_img, found_locations);
 
-        cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
-    }
-    catch (...)
+#if defined (LOG_CASCADE_STATISTIC)
+    for (int i = 0; i < (int)found_locations.size(); i++)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Rect r = found_locations[i];
+
+        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
     }
+
+    cv::imshow("Res", markedImage); cv::waitKey();
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
@@ -375,17 +352,9 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_Read_classifier, Accuracy)
 {
-    try
-    {
-        cv::gpu::CascadeClassifier_GPU classifier;
-        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-        ASSERT_TRUE(classifier.load(classifierXmlPath));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::gpu::CascadeClassifier_GPU classifier;
+    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+    ASSERT_TRUE(classifier.load(classifierXmlPath));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
@@ -405,57 +374,49 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_classify, Accuracy)
 {
-    try
-    {
-        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-        std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
-
-        cv::CascadeClassifier cpuClassifier(classifierXmlPath);
-        ASSERT_FALSE(cpuClassifier.empty());
+    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+    std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
 
-        cv::Mat image = cv::imread(imagePath);
-        image = image.colRange(0, image.cols/2);
-        cv::Mat grey;
-        cvtColor(image, grey, CV_BGR2GRAY);
-        ASSERT_FALSE(image.empty());
+    cv::CascadeClassifier cpuClassifier(classifierXmlPath);
+    ASSERT_FALSE(cpuClassifier.empty());
 
-        std::vector<cv::Rect> rects;
-        cpuClassifier.detectMultiScale(grey, rects);
-        cv::Mat markedImage = image.clone();
+    cv::Mat image = cv::imread(imagePath);
+    image = image.colRange(0, image.cols/2);
+    cv::Mat grey;
+    cvtColor(image, grey, CV_BGR2GRAY);
+    ASSERT_FALSE(image.empty());
 
-        std::vector<cv::Rect>::iterator it = rects.begin();
-        for (; it != rects.end(); ++it)
-            cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
+    std::vector<cv::Rect> rects;
+    cpuClassifier.detectMultiScale(grey, rects);
+    cv::Mat markedImage = image.clone();
 
-        cv::gpu::CascadeClassifier_GPU gpuClassifier;
-        ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
+    std::vector<cv::Rect>::iterator it = rects.begin();
+    for (; it != rects.end(); ++it)
+        cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
 
-        cv::gpu::GpuMat gpu_rects;
-        cv::gpu::GpuMat tested(grey);
-        int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
+    cv::gpu::CascadeClassifier_GPU gpuClassifier;
+    ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
 
-    #if defined (LOG_CASCADE_STATISTIC)
-        cv::Mat downloaded(gpu_rects);
-        const cv::Rect* faces = downloaded.ptr<cv::Rect>();
-        for (int i = 0; i < count; i++)
-        {
-            cv::Rect r = faces[i];
-
-            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
-        }
-    #endif
+    cv::gpu::GpuMat gpu_rects;
+    cv::gpu::GpuMat tested(grey);
+    int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
 
-    #if defined (LOG_CASCADE_STATISTIC)
-        cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
-        (void)count;
-    }
-    catch (...)
+#if defined (LOG_CASCADE_STATISTIC)
+    cv::Mat downloaded(gpu_rects);
+    const cv::Rect* faces = downloaded.ptr<cv::Rect>();
+    for (int i = 0; i < count; i++)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Rect r = faces[i];
+
+        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
     }
+#endif
+
+#if defined (LOG_CASCADE_STATISTIC)
+    cv::imshow("Res", markedImage); cv::waitKey();
+#endif
+    (void)count;
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index 4be0c15..3bb3e09 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -70,402 +70,258 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
 
 TEST_P(GlBuffer, Constructor1)
 {
-    try
-    {
-        cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, Constructor2)
 {
-    try
-    {
-        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, ConstructorFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, ConstructorFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
+    cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, ConstructorFromGlBuffer)
 {
-    try
-    {
-        cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer buf(buf_gold);
+    cv::GlBuffer buf(buf_gold);
 
-        EXPECT_EQ(buf_gold.bufId(), buf.bufId());
-        EXPECT_EQ(buf_gold.rows(), buf.rows());
-        EXPECT_EQ(buf_gold.cols(), buf.cols());
-        EXPECT_EQ(buf_gold.type(), buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(buf_gold.bufId(), buf.bufId());
+    EXPECT_EQ(buf_gold.rows(), buf.rows());
+    EXPECT_EQ(buf_gold.cols(), buf.cols());
+    EXPECT_EQ(buf_gold.type(), buf.type());
 }
 
 TEST_P(GlBuffer, ConstructorFromGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
-        cv::GlTexture2D tex_gold(gold, true);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold, true);
 
-        cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 TEST_P(GlBuffer, Create)
 {
-    try
-    {
-        cv::GlBuffer buf;
-        buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, CopyFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf_gold.bufId(), buf.bufId());
+    EXPECT_NE(buf_gold.bufId(), buf.bufId());
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
-        cv::GlTexture2D tex_gold(gold, true);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold, true);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 TEST_P(GlBuffer, CopyToGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::gpu::GpuMat dst;
-        buf.copyTo(dst);
+    cv::gpu::GpuMat dst;
+    buf.copyTo(dst);
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, dst, 0);
 }
 
 TEST_P(GlBuffer, CopyToGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer dst;
-        buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer dst;
+    buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf.bufId(), dst.bufId());
+    EXPECT_NE(buf.bufId(), dst.bufId());
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyToGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::GlTexture2D tex;
-        buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlTexture2D tex;
+    buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData);
+    cv::Mat texData;
+    tex.copyTo(texData);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlBuffer, Clone)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf.bufId(), dst.bufId());
+    EXPECT_NE(buf.bufId(), dst.bufId());
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, MapHostRead)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
+    EXPECT_MAT_NEAR(gold, dst, 0);
 
-        buf.unmapHost();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    buf.unmapHost();
 }
 
 TEST_P(GlBuffer, MapHostWrite)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
-        gold.copyTo(dst);
-        buf.unmapHost();
-        dst.release();
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
+    gold.copyTo(dst);
+    buf.unmapHost();
+    dst.release();
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, MapDevice)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::gpu::GpuMat dst = buf.mapDevice();
+    cv::gpu::GpuMat dst = buf.mapDevice();
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
+    EXPECT_MAT_NEAR(gold, dst, 0);
 
-        buf.unmapDevice();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    buf.unmapDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@@ -504,243 +360,147 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
 
 TEST_P(GlTexture2D, Constructor1)
 {
-    try
-    {
-        cv::GlTexture2D tex(size.height, size.width, format, true);
+    cv::GlTexture2D tex(size.height, size.width, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, Constructor2)
 {
-    try
-    {
-        cv::GlTexture2D tex(size, format, true);
+    cv::GlTexture2D tex(size, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, ConstructorFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlTexture2D tex(d_gold, true);
+    cv::GlTexture2D tex(d_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-        cv::GlTexture2D tex(buf_gold, true);
+    cv::GlTexture2D tex(buf_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
 {
-    try
-    {
-        cv::GlTexture2D tex_gold(size, format, true);
-        cv::GlTexture2D tex(tex_gold);
+    cv::GlTexture2D tex_gold(size, format, true);
+    cv::GlTexture2D tex(tex_gold);
 
-        EXPECT_EQ(tex_gold.texId(), tex.texId());
-        EXPECT_EQ(tex_gold.rows(), tex.rows());
-        EXPECT_EQ(tex_gold.cols(), tex.cols());
-        EXPECT_EQ(tex_gold.format(), tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(tex_gold.texId(), tex.texId());
+    EXPECT_EQ(tex_gold.rows(), tex.rows());
+    EXPECT_EQ(tex_gold.cols(), tex.cols());
+    EXPECT_EQ(tex_gold.format(), tex.format());
 }
 
 TEST_P(GlTexture2D, Create)
 {
-    try
-    {
-        cv::GlTexture2D tex;
-        tex.create(size.height, size.width, format, true);
+    cv::GlTexture2D tex;
+    tex.create(size.height, size.width, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, CopyFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(d_gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(d_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(buf_gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(buf_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyToGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::gpu::GpuMat dst;
-        tex.copyTo(dst, depth);
+    cv::gpu::GpuMat dst;
+    tex.copyTo(dst, depth);
 
-        EXPECT_MAT_NEAR(gold, dst, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, dst, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyToGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::GlBuffer dst;
-        tex.copyTo(dst, depth, true);
+    cv::GlBuffer dst;
+    tex.copyTo(dst, depth, true);
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp
index ae91b19..1abd784 100644
--- a/modules/gpu/test/test_pyramids.cpp
+++ b/modules/gpu/test/test_pyramids.cpp
@@ -66,23 +66,15 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrDown, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
-        cv::gpu::pyrDown(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
+    cv::gpu::pyrDown(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::pyrDown(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::pyrDown(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
@@ -114,23 +106,15 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrUp, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
-        cv::gpu::pyrUp(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
+    cv::gpu::pyrUp(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::pyrUp(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::pyrUp(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp
index e8b44b5..978e104 100644
--- a/modules/gpu/test/test_remap.cpp
+++ b/modules/gpu/test/test_remap.cpp
@@ -154,24 +154,16 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
 
 TEST_P(Remap, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
-        cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
+    cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
+    cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
 
-        cv::Mat dst_gold;
-        remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp
index b1b30bb..cae2dbf 100644
--- a/modules/gpu/test/test_resize.cpp
+++ b/modules/gpu/test/test_resize.cpp
@@ -138,23 +138,15 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
 
 TEST_P(Resize, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        resizeGold(src, dst_gold, coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
@@ -192,23 +184,15 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
 // downscaling only: used for classifiers
 TEST_P(ResizeSameAsHost, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
@@ -242,24 +226,16 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
 
 TEST_P(ResizeNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst;
+    cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        resizeGold(src, dst_gold, coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 695280d..cc39740 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include <test_precomp.hpp>
 #include <time.h>
 
 #ifdef HAVE_CUDA
@@ -158,77 +158,62 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
-    try
-    {
-        cv::gpu::setDevice(GET_PARAM(0).deviceID());
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
-        ASSERT_FALSE(coloredCpu.empty());
-
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GET_PARAM(0).deviceID());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
+    ASSERT_FALSE(coloredCpu.empty());
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::gpu::SCascade cascade;
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        int nroi = GET_PARAM(3);
-        cv::Mat result(coloredCpu);
-        cv::RNG rng;
-        for (int i = 0; i < nroi; ++i)
-        {
-            cv::Rect r = getFromTable(rng(10));
-            GpuMat sub(rois, r);
-            sub.setTo(1);
-            cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
-        }
-        objectBoxes.setTo(0);
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
 
-        cascade.detect(colored, rois, objectBoxes);
+    int nroi = GET_PARAM(3);
+    cv::Mat result(coloredCpu);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
+    {
+        cv::Rect r = getFromTable(rng(10));
+        GpuMat sub(rois, r);
+        sub.setTo(1);
+        cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
+    }
+    objectBoxes.setTo(0);
 
-        cv::Mat dt(objectBoxes);
-        typedef cv::gpu::SCascade::Detection Detection;
+    cascade.detect(colored, rois, objectBoxes);
 
-        Detection* dts = ((Detection*)dt.data) + 1;
-        int* count = dt.ptr<int>(0);
+    cv::Mat dt(objectBoxes);
+    typedef cv::gpu::SCascade::Detection Detection;
 
-        printTotal(std::cout, *count);
+    Detection* dts = ((Detection*)dt.data) + 1;
+    int* count = dt.ptr<int>(0);
 
-        for (int i = 0; i  < *count; ++i)
-        {
-            Detection d = dts[i];
-            print(std::cout, d);
-            cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
-        }
+    printTotal(std::cout, *count);
 
-        SHOW(result);
-    }
-    catch (...)
+    for (int i = 0; i  < *count; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        Detection d = dts[i];
+        print(std::cout, d);
+        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
     }
+
+    SHOW(result);
+
 }
 
 TEST(SCascadeTest, readCascade)
 {
-    try
-    {
-        std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
-        cv::gpu::SCascade cascade;
+    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 }
 
 typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
@@ -236,129 +221,105 @@ GPU_TEST_P(SCascadeTestAll, detect,
         ALL_DEVICES
         )
 {
-    try
-    {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-        ASSERT_FALSE(coloredCpu.empty());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
 
-        GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-        sub.setTo(cv::Scalar::all(1));
+    GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
 
-        objectBoxes.setTo(0);
-        cascade.detect(colored, rois, objectBoxes);
+    objectBoxes.setTo(0);
+    cascade.detect(colored, rois, objectBoxes);
 
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2448);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )
 {
-    try
-    {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
-        cv::FileStorage fsi(intPath, cv::FileStorage::READ);
-        ASSERT_TRUE(fsi.isOpened());
+    std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
+    cv::FileStorage fsi(intPath, cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
 
-        GpuMat hogluv(121 * 10, 161, CV_32SC1);
-        for (int i = 0; i < 10; ++i)
-        {
-            cv::Mat channel;
-            fsi[std::string("channel") + itoa(i)] >> channel;
-            GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-            gchannel.upload(channel);
-        }
+    GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
+    {
+        cv::Mat channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
+        GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
 
-        GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-        rois.setTo(1);
+    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+    rois.setTo(1);
 
-        objectBoxes.setTo(0);
-        cascade.detect(hogluv, rois, objectBoxes);
+    objectBoxes.setTo(0);
+    cascade.detect(hogluv, rois, objectBoxes);
 
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
 
-        ASSERT_EQ(a, 1024);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ( a ,1024);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectStream,
         ALL_DEVICES
         )
 {
-    try
-    {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-        ASSERT_FALSE(coloredCpu.empty());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
 
-        GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-        sub.setTo(cv::Scalar::all(1));
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
 
-        cv::gpu::Stream s;
+    cv::gpu::Stream s;
 
-        objectBoxes.setTo(0);
-        cascade.detect(colored, rois, objectBoxes, s);
-        s.waitForCompletion();
+    objectBoxes.setTo(0);
+    cascade.detect(colored, rois, objectBoxes, s);
+    s.waitForCompletion();
 
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2448);
 }
 
 
-#endif
+#endif
\ No newline at end of file
diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp
index 38d92a6..c569210 100644
--- a/modules/gpu/test/test_threshold.cpp
+++ b/modules/gpu/test/test_threshold.cpp
@@ -68,25 +68,17 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
 
 TEST_P(Threshold, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        double maxVal = randomDouble(20.0, 127.0);
-        double thresh = randomDouble(0.0, maxVal);
+    cv::Mat src = randomMat(size, type);
+    double maxVal = randomDouble(20.0, 127.0);
+    double thresh = randomDouble(0.0, maxVal);
 
-        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
+    cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
 
-        cv::Mat dst_gold;
-        cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+    cv::Mat dst_gold;
+    cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index d1332ce..c56e3d2 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -65,74 +65,67 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BroxOpticalFlow, Regression)
 {
-    try
-    {
-        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                      10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-        cv::gpu::GpuMat u;
-        cv::gpu::GpuMat v;
-        brox(loadMat(frame0), loadMat(frame1), u, v);
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(frame0), loadMat(frame1), u, v);
 
-    #ifndef DUMP
-        std::string fname(cvtest::TS::ptr()->get_data_path());
-        if (devInfo.majorVersion() >= 2)
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-        else
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+#ifndef DUMP
+    std::string fname(cvtest::TS::ptr()->get_data_path());
+    if (devInfo.majorVersion() >= 2)
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+    else
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-        std::ifstream f(fname.c_str(), std::ios_base::binary);
+    std::ifstream f(fname.c_str(), std::ios_base::binary);
 
-        int rows, cols;
+    int rows, cols;
 
-        f.read((char*)&rows, sizeof(rows));
-        f.read((char*)&cols, sizeof(cols));
+    f.read((char*)&rows, sizeof(rows));
+    f.read((char*)&cols, sizeof(cols));
 
-        cv::Mat u_gold(rows, cols, CV_32FC1);
+    cv::Mat u_gold(rows, cols, CV_32FC1);
 
-        for (int i = 0; i < u_gold.rows; ++i)
-            f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
+    for (int i = 0; i < u_gold.rows; ++i)
+        f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
 
-        cv::Mat v_gold(rows, cols, CV_32FC1);
+    cv::Mat v_gold(rows, cols, CV_32FC1);
 
-        for (int i = 0; i < v_gold.rows; ++i)
-            f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
+    for (int i = 0; i < v_gold.rows; ++i)
+        f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
 
-        EXPECT_MAT_NEAR(u_gold, u, 0);
-        EXPECT_MAT_NEAR(v_gold, v, 0);
-    #else
-        std::string fname(cvtest::TS::ptr()->get_data_path());
-        if (devInfo.majorVersion() >= 2)
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-        else
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+    EXPECT_MAT_NEAR(u_gold, u, 0);
+    EXPECT_MAT_NEAR(v_gold, v, 0);
+#else
+    std::string fname(cvtest::TS::ptr()->get_data_path());
+    if (devInfo.majorVersion() >= 2)
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+    else
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-        std::ofstream f(fname.c_str(), std::ios_base::binary);
+    std::ofstream f(fname.c_str(), std::ios_base::binary);
 
-        f.write((char*)&u.rows, sizeof(u.rows));
-        f.write((char*)&u.cols, sizeof(u.cols));
+    f.write((char*)&u.rows, sizeof(u.rows));
+    f.write((char*)&u.cols, sizeof(u.cols));
 
-        cv::Mat h_u(u);
-        cv::Mat h_v(v);
+    cv::Mat h_u(u);
+    cv::Mat h_v(v);
 
-        for (int i = 0; i < u.rows; ++i)
-            f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
+    for (int i = 0; i < u.rows; ++i)
+        f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
 
-        for (int i = 0; i < v.rows; ++i)
-            f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
-    #endif
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    for (int i = 0; i < v.rows; ++i)
+        f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
+
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@@ -158,16 +151,28 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
 
 TEST_P(GoodFeaturesToTrack, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-        int maxCorners = 1000;
-        double qualityLevel = 0.01;
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
 
-        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_pts;
+            detector(loadMat(image), d_pts);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         cv::gpu::GpuMat d_pts;
         detector(loadMat(image), d_pts);
 
@@ -196,34 +201,21 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
 
         ASSERT_LE(bad_ratio, 0.01);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(GoodFeaturesToTrack, EmptyCorners)
 {
-    try
-    {
-        int maxCorners = 1000;
-        double qualityLevel = 0.01;
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
 
-        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
 
-        cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
-        cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
+    cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+    cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
 
-        detector(src, corners);
+    detector(src, corners);
 
-        ASSERT_TRUE( corners.empty() );
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE( corners.empty() );
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
@@ -251,78 +243,70 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
 
 TEST_P(PyrLKOpticalFlow, Sparse)
 {
-    try
-    {
-        cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::Mat gray_frame;
-        if (useGray)
-            gray_frame = frame0;
-        else
-            cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
+    cv::Mat gray_frame;
+    if (useGray)
+        gray_frame = frame0;
+    else
+        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
 
-        std::vector<cv::Point2f> pts;
-        cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
+    std::vector<cv::Point2f> pts;
+    cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
 
-        cv::gpu::GpuMat d_pts;
-        cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
-        d_pts.upload(pts_mat);
+    cv::gpu::GpuMat d_pts;
+    cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
+    d_pts.upload(pts_mat);
 
-        cv::gpu::PyrLKOpticalFlow pyrLK;
+    cv::gpu::PyrLKOpticalFlow pyrLK;
 
-        cv::gpu::GpuMat d_nextPts;
-        cv::gpu::GpuMat d_status;
-        pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
+    cv::gpu::GpuMat d_nextPts;
+    cv::gpu::GpuMat d_status;
+    pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
 
-        std::vector<cv::Point2f> nextPts(d_nextPts.cols);
-        cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
-        d_nextPts.download(nextPts_mat);
+    std::vector<cv::Point2f> nextPts(d_nextPts.cols);
+    cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
+    d_nextPts.download(nextPts_mat);
 
-        std::vector<unsigned char> status(d_status.cols);
-        cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
-        d_status.download(status_mat);
+    std::vector<unsigned char> status(d_status.cols);
+    cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
+    d_status.download(status_mat);
 
-        std::vector<cv::Point2f> nextPts_gold;
-        std::vector<unsigned char> status_gold;
-        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
+    std::vector<cv::Point2f> nextPts_gold;
+    std::vector<unsigned char> status_gold;
+    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
 
-        ASSERT_EQ(nextPts_gold.size(), nextPts.size());
-        ASSERT_EQ(status_gold.size(), status.size());
+    ASSERT_EQ(nextPts_gold.size(), nextPts.size());
+    ASSERT_EQ(status_gold.size(), status.size());
 
-        size_t mistmatch = 0;
-        for (size_t i = 0; i < nextPts.size(); ++i)
-        {
-            cv::Point2i a = nextPts[i];
-            cv::Point2i b = nextPts_gold[i];
+    size_t mistmatch = 0;
+    for (size_t i = 0; i < nextPts.size(); ++i)
+    {
+        cv::Point2i a = nextPts[i];
+        cv::Point2i b = nextPts_gold[i];
 
-            if (status[i] != status_gold[i])
-            {
-                ++mistmatch;
-                continue;
-            }
+        if (status[i] != status_gold[i])
+        {
+            ++mistmatch;
+            continue;
+        }
 
-            if (status[i])
-            {
-                bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
+        if (status[i])
+        {
+            bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
 
-                if (!eq)
-                    ++mistmatch;
-            }
+            if (!eq)
+                ++mistmatch;
         }
+    }
 
-        double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+    double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
 
-        ASSERT_LE(bad_ratio, 0.01);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_LE(bad_ratio, 0.01);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
@@ -359,53 +343,45 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn
 
 TEST_P(FarnebackOpticalFlow, Accuracy)
 {
-    try
-    {
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        double polySigma = polyN <= 5 ? 1.1 : 1.5;
+    double polySigma = polyN <= 5 ? 1.1 : 1.5;
 
-        cv::gpu::FarnebackOpticalFlow calc;
-        calc.pyrScale = pyrScale;
-        calc.polyN = polyN;
-        calc.polySigma = polySigma;
-        calc.flags = flags;
+    cv::gpu::FarnebackOpticalFlow calc;
+    calc.pyrScale = pyrScale;
+    calc.polyN = polyN;
+    calc.polySigma = polySigma;
+    calc.flags = flags;
 
-        cv::gpu::GpuMat d_flowx, d_flowy;
-        calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+    cv::gpu::GpuMat d_flowx, d_flowy;
+    calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
 
-        cv::Mat flow;
-        if (useInitFlow)
-        {
-            cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
-            cv::merge(flowxy, 2, flow);
-        }
+    cv::Mat flow;
+    if (useInitFlow)
+    {
+        cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
+        cv::merge(flowxy, 2, flow);
+    }
 
-        if (useInitFlow)
-        {
-            calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
-            calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-        }
+    if (useInitFlow)
+    {
+        calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
+        calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+    }
 
-        cv::calcOpticalFlowFarneback(
-            frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
-            calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
+    cv::calcOpticalFlowFarneback(
+        frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
+        calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
 
-        std::vector<cv::Mat> flowxy;
-        cv::split(flow, flowxy);
+    std::vector<cv::Mat> flowxy;
+    cv::split(flow, flowxy);
 
-        EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
-        EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
+    EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
@@ -419,35 +395,27 @@ struct OpticalFlowNan : public BroxOpticalFlow {};
 
 TEST_P(OpticalFlowNan, Regression)
 {
-    try
-    {
-        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-        ASSERT_FALSE(frame0.empty());
-        cv::Mat r_frame0, r_frame1;
-        cv::resize(frame0, r_frame0, cv::Size(1380,1000));
-
-        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-        ASSERT_FALSE(frame1.empty());
-        cv::resize(frame1, r_frame1, cv::Size(1380,1000));
-
-        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                      5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-        cv::gpu::GpuMat u;
-        cv::gpu::GpuMat v;
-        brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
-
-        cv::Mat h_u, h_v;
-        u.download(h_u);
-        v.download(h_v);
-        EXPECT_TRUE(cv::checkRange(h_u));
-        EXPECT_TRUE(cv::checkRange(h_v));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
+    cv::Mat r_frame0, r_frame1;
+    cv::resize(frame0, r_frame0, cv::Size(1380,1000));
+
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
+    cv::resize(frame1, r_frame1, cv::Size(1380,1000));
+
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
+
+    cv::Mat h_u, h_v;
+    u.download(h_u);
+    v.download(h_v);
+    EXPECT_TRUE(cv::checkRange(h_u));
+    EXPECT_TRUE(cv::checkRange(h_v));
 };
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
@@ -461,38 +429,30 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(OpticalFlowDual_TVL1, Accuracy)
 {
-    try
-    {
-        cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        const bool useRoi = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(1);
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-        cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
-        cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
-        d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
 
-        cv::OpticalFlowDual_TVL1 alg;
-        cv::Mat flow;
-        alg(frame0, frame1, flow);
-        cv::Mat gold[2];
-        cv::split(flow, gold);
+    cv::OpticalFlowDual_TVL1 alg;
+    cv::Mat flow;
+    alg(frame0, frame1, flow);
+    cv::Mat gold[2];
+    cv::split(flow, gold);
 
-        EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
-        EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
@@ -526,37 +486,29 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(OpticalFlowBM, Accuracy)
 {
-    try
-    {
-        cv::gpu::DeviceInfo devInfo = GetParam();
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::Size block_size(16, 16);
-        cv::Size shift_size(1, 1);
-        cv::Size max_range(16, 16);
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
 
-        cv::gpu::GpuMat d_velx, d_vely, buf;
-        cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
-                                   block_size, shift_size, max_range, false,
-                                   d_velx, d_vely, buf);
+    cv::gpu::GpuMat d_velx, d_vely, buf;
+    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+                               block_size, shift_size, max_range, false,
+                               d_velx, d_vely, buf);
 
-        cv::Mat velx, vely;
-        calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+    cv::Mat velx, vely;
+    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
 
-        EXPECT_MAT_NEAR(velx, d_velx, 0);
-        EXPECT_MAT_NEAR(vely, d_vely, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(velx, d_velx, 0);
+    EXPECT_MAT_NEAR(vely, d_vely, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
@@ -634,52 +586,44 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastOpticalFlowBM, Accuracy)
 {
-    try
-    {
-        const double MAX_RMSE = 0.6;
+    const double MAX_RMSE = 0.6;
 
-        int search_window = 15;
-        int block_window = 5;
+    int search_window = 15;
+    int block_window = 5;
 
-        cv::gpu::DeviceInfo devInfo = GetParam();
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::Size smallSize(320, 240);
-        cv::Mat frame0_small;
-        cv::Mat frame1_small;
+    cv::Size smallSize(320, 240);
+    cv::Mat frame0_small;
+    cv::Mat frame1_small;
 
-        cv::resize(frame0, frame0_small, smallSize);
-        cv::resize(frame1, frame1_small, smallSize);
+    cv::resize(frame0, frame0_small, smallSize);
+    cv::resize(frame1, frame1_small, smallSize);
 
-        cv::gpu::GpuMat d_flowx;
-        cv::gpu::GpuMat d_flowy;
-        cv::gpu::FastOpticalFlowBM fastBM;
+    cv::gpu::GpuMat d_flowx;
+    cv::gpu::GpuMat d_flowy;
+    cv::gpu::FastOpticalFlowBM fastBM;
 
-        fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
 
-        cv::Mat_<float> flowx;
-        cv::Mat_<float> flowy;
-        FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+    cv::Mat_<float> flowx;
+    cv::Mat_<float> flowy;
+    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
 
-        double err;
+    double err;
 
-        err = calc_rmse(flowx, cv::Mat(d_flowx));
-        EXPECT_LE(err, MAX_RMSE);
+    err = calc_rmse(flowx, cv::Mat(d_flowx));
+    EXPECT_LE(err, MAX_RMSE);
 
-        err = calc_rmse(flowy, cv::Mat(d_flowy));
-        EXPECT_LE(err, MAX_RMSE);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    err = calc_rmse(flowy, cv::Mat(d_flowy));
+    EXPECT_LE(err, MAX_RMSE);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
@@ -714,63 +658,55 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
 
 TEST_P(FGDStatModel, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
 
-        IplImage ipl_frame = frame;
-        cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+    IplImage ipl_frame = frame;
+    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
 
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::FGDStatModel d_model(out_cn);
-        d_model.create(d_frame);
+    cv::gpu::GpuMat d_frame(frame);
+    cv::gpu::FGDStatModel d_model(out_cn);
+    d_model.create(d_frame);
 
-        cv::Mat h_background;
-        cv::Mat h_foreground;
-        cv::Mat h_background3;
+    cv::Mat h_background;
+    cv::Mat h_foreground;
+    cv::Mat h_background3;
 
-        cv::Mat backgroundDiff;
-        cv::Mat foregroundDiff;
+    cv::Mat backgroundDiff;
+    cv::Mat foregroundDiff;
 
-        for (int i = 0; i < 5; ++i)
-        {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            ipl_frame = frame;
-            int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
+    for (int i = 0; i < 5; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
 
-            d_frame.upload(frame);
+        ipl_frame = frame;
+        int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
 
-            int count = d_model.update(d_frame);
+        d_frame.upload(frame);
 
-            ASSERT_EQ(gold_count, count);
+        int count = d_model.update(d_frame);
 
-            cv::Mat gold_background(model->background);
-            cv::Mat gold_foreground(model->foreground);
+        ASSERT_EQ(gold_count, count);
 
-            if (out_cn == 3)
-                d_model.background.download(h_background3);
-            else
-            {
-                d_model.background.download(h_background);
-                cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
-            }
-            d_model.foreground.download(h_foreground);
+        cv::Mat gold_background(model->background);
+        cv::Mat gold_foreground(model->foreground);
 
-            ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
-            ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+        if (out_cn == 3)
+            d_model.background.download(h_background3);
+        else
+        {
+            d_model.background.download(h_background);
+            cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        d_model.foreground.download(h_foreground);
+
+        ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
+        ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
     }
 }
 
@@ -809,44 +745,36 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us
 
 TEST_P(MOG, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
 
-        cv::gpu::MOG_GPU mog;
-        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+    cv::gpu::MOG_GPU mog;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
 
-        cv::BackgroundSubtractorMOG mog_gold;
-        cv::Mat foreground_gold;
+    cv::BackgroundSubtractorMOG mog_gold;
+    cv::Mat foreground_gold;
 
-        for (int i = 0; i < 10; ++i)
-        {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
 
-            if (useGray)
-            {
-                cv::Mat temp;
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                cv::swap(temp, frame);
-            }
+        if (useGray)
+        {
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
+        }
 
-            mog(loadMat(frame, useRoi), foreground, (float)learningRate);
+        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
 
-            mog_gold(frame, foreground_gold, learningRate);
+        mog_gold(frame, foreground_gold, learningRate);
 
-            ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
     }
 }
 
@@ -882,48 +810,40 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
 
 TEST_P(MOG2, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
 
-        cv::gpu::MOG2_GPU mog2;
-        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
 
-        cv::BackgroundSubtractorMOG2 mog2_gold;
-        cv::Mat foreground_gold;
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
 
-        for (int i = 0; i < 10; ++i)
-        {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
 
-            if (useGray)
-            {
-                cv::Mat temp;
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                cv::swap(temp, frame);
-            }
+        if (useGray)
+        {
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
+        }
 
-            mog2(loadMat(frame, useRoi), foreground);
+        mog2(loadMat(frame, useRoi), foreground);
 
-            mog2_gold(frame, foreground_gold);
+        mog2_gold(frame, foreground_gold);
 
-            double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
+        double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
 
-            norm /= foreground_gold.size().area();
+        norm /= foreground_gold.size().area();
 
-            ASSERT_LE(norm, 0.09);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_LE(norm, 0.09);
     }
 }
 
@@ -932,42 +852,34 @@ TEST_P(MOG2, getBackgroundImage)
     if (useGray)
         return;
 
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
+    cv::Mat frame;
 
-        cv::gpu::MOG2_GPU mog2;
-        cv::gpu::GpuMat foreground;
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground;
 
-        cv::BackgroundSubtractorMOG2 mog2_gold;
-        cv::Mat foreground_gold;
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
 
-        for (int i = 0; i < 10; ++i)
-        {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
 
-            mog2(loadMat(frame, useRoi), foreground);
+        mog2(loadMat(frame, useRoi), foreground);
 
-            mog2_gold(frame, foreground_gold);
-        }
+        mog2_gold(frame, foreground_gold);
+    }
 
-        cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
-        mog2.getBackgroundImage(background);
+    cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
+    mog2.getBackgroundImage(background);
 
-        cv::Mat background_gold;
-        mog2_gold.getBackgroundImage(background_gold);
+    cv::Mat background_gold;
+    mog2_gold.getBackgroundImage(background_gold);
 
-        ASSERT_MAT_NEAR(background_gold, background, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_MAT_NEAR(background_gold, background, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
@@ -985,38 +897,30 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(VIBE, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const int type = GET_PARAM(2);
-        const bool useRoi = GET_PARAM(3);
-
-        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int type = GET_PARAM(2);
+    const bool useRoi = GET_PARAM(3);
 
-        cv::Mat frame = randomMat(size, type, 0.0, 100);
-        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
 
-        cv::gpu::VIBE_GPU vibe;
-        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-        vibe.initialize(d_frame);
+    cv::Mat frame = randomMat(size, type, 0.0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
 
-        for (int i = 0; i < 20; ++i)
-            vibe(d_frame, d_fgmask);
+    cv::gpu::VIBE_GPU vibe;
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+    vibe.initialize(d_frame);
 
-        frame = randomMat(size, type, 160, 255);
-        d_frame = loadMat(frame, useRoi);
+    for (int i = 0; i < 20; ++i)
         vibe(d_frame, d_fgmask);
 
-        // now fgmask should be entirely foreground
-        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    vibe(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
@@ -1034,50 +938,42 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
 
 TEST_P(GMG, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const int depth = GET_PARAM(2);
-        const int channels = GET_PARAM(3);
-        const bool useRoi = GET_PARAM(4);
-
-        const int type = CV_MAKE_TYPE(depth, channels);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int depth = GET_PARAM(2);
+    const int channels = GET_PARAM(3);
+    const bool useRoi = GET_PARAM(4);
 
-        const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
-        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+    const int type = CV_MAKE_TYPE(depth, channels);
 
-        cv::Mat frame = randomMat(size, type, 0, 100);
-        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+    const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
 
-        cv::gpu::GMG_GPU gmg;
-        gmg.numInitializationFrames = 5;
-        gmg.smoothingRadius = 0;
-        gmg.initialize(d_frame.size(), 0, 255);
+    cv::Mat frame = randomMat(size, type, 0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
 
-        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+    cv::gpu::GMG_GPU gmg;
+    gmg.numInitializationFrames = 5;
+    gmg.smoothingRadius = 0;
+    gmg.initialize(d_frame.size(), 0, 255);
 
-        for (int i = 0; i < gmg.numInitializationFrames; ++i)
-        {
-            gmg(d_frame, d_fgmask);
-
-            // fgmask should be entirely background during training
-            ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
-        }
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
 
-        frame = randomMat(size, type, 160, 255);
-        d_frame = loadMat(frame, useRoi);
+    for (int i = 0; i < gmg.numInitializationFrames; ++i)
+    {
         gmg(d_frame, d_fgmask);
 
-        // now fgmask should be entirely foreground
-        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        // fgmask should be entirely background during training
+        ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
     }
+
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    gmg(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
@@ -1113,47 +1009,39 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoWriter, Regression)
 {
-    try
-    {
-        const double FPS = 25.0;
+    const double FPS = 25.0;
 
-        cv::VideoCapture reader(inputFile);
-        ASSERT_TRUE( reader.isOpened() );
+    cv::VideoCapture reader(inputFile);
+    ASSERT_TRUE( reader.isOpened() );
 
-        cv::gpu::VideoWriter_GPU d_writer;
+    cv::gpu::VideoWriter_GPU d_writer;
 
-        cv::Mat frame;
-        cv::gpu::GpuMat d_frame;
+    cv::Mat frame;
+    cv::gpu::GpuMat d_frame;
 
-        for (int i = 0; i < 10; ++i)
-        {
-            reader >> frame;
-            ASSERT_FALSE(frame.empty());
+    for (int i = 0; i < 10; ++i)
+    {
+        reader >> frame;
+        ASSERT_FALSE(frame.empty());
 
-            d_frame.upload(frame);
+        d_frame.upload(frame);
 
-            if (!d_writer.isOpened())
-                d_writer.open(outputFile, frame.size(), FPS);
+        if (!d_writer.isOpened())
+            d_writer.open(outputFile, frame.size(), FPS);
 
-            d_writer.write(d_frame);
-        }
+        d_writer.write(d_frame);
+    }
 
-        reader.release();
-        d_writer.close();
+    reader.release();
+    d_writer.close();
 
-        reader.open(outputFile);
-        ASSERT_TRUE( reader.isOpened() );
+    reader.open(outputFile);
+    ASSERT_TRUE( reader.isOpened() );
 
-        for (int i = 0; i < 5; ++i)
-        {
-            reader >> frame;
-            ASSERT_FALSE( frame.empty() );
-        }
-    }
-    catch (...)
+    for (int i = 0; i < 5; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        reader >> frame;
+        ASSERT_FALSE( frame.empty() );
     }
 }
 
@@ -1182,27 +1070,19 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoReader, Regression)
 {
-    try
-    {
-        cv::gpu::VideoReader_GPU reader(inputFile);
-        ASSERT_TRUE( reader.isOpened() );
+    cv::gpu::VideoReader_GPU reader(inputFile);
+    ASSERT_TRUE( reader.isOpened() );
 
-        cv::gpu::GpuMat frame;
+    cv::gpu::GpuMat frame;
 
-        for (int i = 0; i < 10; ++i)
-        {
-            ASSERT_TRUE( reader.read(frame) );
-            ASSERT_FALSE( frame.empty() );
-        }
-
-        reader.close();
-        ASSERT_FALSE( reader.isOpened() );
-    }
-    catch (...)
+    for (int i = 0; i < 10; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_TRUE( reader.read(frame) );
+        ASSERT_FALSE( frame.empty() );
     }
+
+    reader.close();
+    ASSERT_FALSE( reader.isOpened() );
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp
index 256f750..065c675 100644
--- a/modules/gpu/test/test_warp_affine.cpp
+++ b/modules/gpu/test/test_warp_affine.cpp
@@ -76,32 +76,24 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
 
 TEST_P(BuildWarpAffineMaps, Accuracy)
 {
-    try
-    {
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-        cv::gpu::GpuMat xmap, ymap;
-        cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+    cv::gpu::GpuMat xmap, ymap;
+    cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
 
-        int interpolation = cv::INTER_NEAREST;
-        int borderMode = cv::BORDER_CONSTANT;
+    int interpolation = cv::INTER_NEAREST;
+    int borderMode = cv::BORDER_CONSTANT;
 
-        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-        cv::Mat dst;
-        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
 
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Mat dst_gold;
-        cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat dst_gold;
+    cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
@@ -209,28 +201,20 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
 
 TEST_P(WarpAffine, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-        cv::Mat dst_gold;
-        warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
@@ -265,27 +249,19 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
 
 TEST_P(WarpAffineNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
+    cv::gpu::GpuMat dst;
+    cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
 
-        cv::Mat dst_gold;
-        warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+    cv::Mat dst_gold;
+    warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp
index 77e88d4..95c089b 100644
--- a/modules/gpu/test/test_warp_perspective.cpp
+++ b/modules/gpu/test/test_warp_perspective.cpp
@@ -77,29 +77,21 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
 
 TEST_P(BuildWarpPerspectiveMaps, Accuracy)
 {
-    try
-    {
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-        cv::gpu::GpuMat xmap, ymap;
-        cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+    cv::gpu::GpuMat xmap, ymap;
+    cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
 
-        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-        cv::Mat dst;
-        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
+    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
 
-        int flags = cv::INTER_NEAREST;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Mat dst_gold;
-        cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
+    int flags = cv::INTER_NEAREST;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat dst_gold;
+    cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
@@ -209,28 +201,20 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
 
 TEST_P(WarpPerspective, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-        cv::Mat dst_gold;
-        warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
@@ -265,27 +249,19 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
 
 TEST_P(WarpPerspectiveNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
+    cv::gpu::GpuMat dst;
+    cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
 
-        cv::Mat dst_gold;
-        warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+    cv::Mat dst_gold;
+    warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(