diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
index 7a9c6c3950..343a4e9fad 100644
--- a/modules/gpu/perf/perf_calib3d.cpp
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -1,207 +1,180 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // StereoBM
 
-GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+typedef pair<string, string> pair_string;
+DEF_PARAM_TEST_1(ImagePair, pair_string);
 
-    cv::Mat img_l_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_l_host.empty());
+PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(make_pair<string, string>("gpu/perf/aloe.jpg", "gpu/perf/aloeR.jpg")))
+{
+    declare.time(5.0);
 
-    cv::Mat img_r_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_r_host.empty());
+    cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::gpu::StereoBM_GPU bm(0, 256);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgRight.empty());
 
-    bm(img_l, img_r, dst);
+    cv::gpu::StereoBM_GPU d_bm(0, 256);
+    cv::gpu::GpuMat d_imgLeft(imgLeft);
+    cv::gpu::GpuMat d_imgRight(imgRight);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(5.0);
+    d_bm(d_imgLeft, d_imgRight, d_dst);
 
     TEST_CYCLE()
     {
-        bm(img_l, img_r, dst);
+        d_bm(d_imgLeft, d_imgRight, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // StereoBeliefPropagation
 
-GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(make_pair<string, string>("gpu/stereobp/aloe-L.png", "gpu/stereobp/aloe-R.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_l_host = readImage("gpu/stereobp/aloe-L.png");
-    ASSERT_FALSE(img_l_host.empty());
+    declare.time(10.0);
 
-    cv::Mat img_r_host = readImage("gpu/stereobp/aloe-R.png");
-    ASSERT_FALSE(img_r_host.empty());
+    cv::Mat imgLeft = readImage(GetParam().first);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::gpu::StereoBeliefPropagation bp(64);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat imgRight = readImage(GetParam().second);
+    ASSERT_FALSE(imgRight.empty());
 
-    bp(img_l, img_r, dst);
+    cv::gpu::StereoBeliefPropagation d_bp(64);
+    cv::gpu::GpuMat d_imgLeft(imgLeft);
+    cv::gpu::GpuMat d_imgRight(imgRight);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(10.0);
+    d_bp(d_imgLeft, d_imgRight, d_dst);
 
     TEST_CYCLE()
     {
-        bp(img_l, img_r, dst);
+        d_bp(d_imgLeft, d_imgRight, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // StereoConstantSpaceBP
 
-GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(make_pair<string, string>("gpu/stereobm/aloe-L.png", "gpu/stereobm/aloe-R.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_l_host.empty());
+    declare.time(10.0);
 
-    cv::Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_r_host.empty());
+    cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::gpu::StereoConstantSpaceBP csbp(128);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgRight.empty());
 
-    csbp(img_l, img_r, dst);
+    cv::gpu::StereoConstantSpaceBP d_csbp(128);
+    cv::gpu::GpuMat d_imgLeft(imgLeft);
+    cv::gpu::GpuMat d_imgRight(imgRight);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(10.0);
+    d_csbp(d_imgLeft, d_imgRight, d_dst);
 
     TEST_CYCLE()
     {
-        csbp(img_l, img_r, dst);
+        d_csbp(d_imgLeft, d_imgRight, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // DisparityBilateralFilter
 
-GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(make_pair<string, string>("gpu/stereobm/aloe-L.png", "gpu/stereobm/aloe-disp.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    cv::Mat disp = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(disp.empty());
 
-    cv::Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(disp_host.empty());
+    cv::gpu::DisparityBilateralFilter d_filter(128);
+    cv::gpu::GpuMat d_img(img);
+    cv::gpu::GpuMat d_disp(disp);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::DisparityBilateralFilter f(128);
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat disp(disp_host);
-    cv::gpu::GpuMat dst;
-
-    f(disp, img, dst);
+    d_filter(d_disp, d_img, d_dst);
 
     TEST_CYCLE()
     {
-        f(disp, img, dst);
+        d_filter(d_disp, d_img, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, DisparityBilateralFilter, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // TransformPoints
 
-IMPLEMENT_PARAM_CLASS(Count, int)
+DEF_PARAM_TEST_1(Count, int);
 
-GPU_PERF_TEST(TransformPoints, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    int count = GetParam();
 
-    int count = GET_PARAM(1);
+    cv::Mat src(1, count, CV_32FC3);
+    fillRandom(src, -100, 100);
 
-    cv::Mat src_host(1, count, CV_32FC3);
-    fill(src_host, -100, 100);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
     cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::transformPoints(src, rvec, tvec, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::transformPoints(src, rvec, tvec, dst);
+        cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
 //////////////////////////////////////////////////////////////////////
 // ProjectPoints
 
-GPU_PERF_TEST(ProjectPoints, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    int count = GET_PARAM(1);
+    int count = GetParam();
 
-    cv::Mat src_host(1, count, CV_32FC3);
-    fill(src_host, -100, 100);
+    cv::Mat src(1, count, CV_32FC3);
+    fillRandom(src, -100, 100);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
     cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
     cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);
+        cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
 //////////////////////////////////////////////////////////////////////
 // SolvePnPRansac
 
-GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(3.0);
 
-    int count = GET_PARAM(1);
+    int count = GetParam();
 
     cv::Mat object(1, count, CV_32FC3);
-    fill(object, -100, 100);
+    fillRandom(object, -100, 100);
 
     cv::Mat camera_mat(3, 3, CV_32FC1);
-    fill(camera_mat, 0.5, 1);
+    fillRandom(camera_mat, 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;
@@ -211,9 +184,9 @@ GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
 
     std::vector<cv::Point2f> image_vec;
     cv::Mat rvec_gold(1, 3, CV_32FC1);
-    fill(rvec_gold, 0, 1);
+    fillRandom(rvec_gold, 0, 1);
     cv::Mat tvec_gold(1, 3, CV_32FC1);
-    fill(tvec_gold, 0, 1);
+    fillRandom(tvec_gold, 0, 1);
     cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, dist_coef, image_vec);
 
     cv::Mat image(1, count, CV_32FC2, &image_vec[0]);
@@ -223,80 +196,57 @@ GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
 
     cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
 
-    declare.time(3.0);
-
     TEST_CYCLE()
     {
         cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
 //////////////////////////////////////////////////////////////////////
 // ReprojectImageTo3D
 
-GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-
-    cv::Mat src_host(size, depth);
-    fill(src_host, 5.0, 30.0);
+    cv::Mat src(size, depth);
+    fillRandom(src, 5.0, 30.0);
 
     cv::Mat Q(4, 4, CV_32FC1);
-    fill(Q, 0.1, 1.0);
+    fillRandom(Q, 0.1, 1.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::reprojectImageTo3D(src, dst, Q);
+    cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
 
     TEST_CYCLE()
     {
-        cv::gpu::reprojectImageTo3D(src, dst, Q);
+        cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, ReprojectImageTo3D, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S)));
-
 //////////////////////////////////////////////////////////////////////
 // DrawColorDisp
 
-GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Mat src(size, type);
+    fillRandom(src, 0, 255);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::drawColorDisp(src, dst, 255);
+    cv::gpu::drawColorDisp(d_src, d_dst, 255);
 
     TEST_CYCLE()
     {
-        cv::gpu::drawColorDisp(src, dst, 255);
+        cv::gpu::drawColorDisp(d_src, d_dst, 255);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, DrawColorDisp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16S))));
-
-#endif
-
+} // namespace
diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index f413432041..b56713a70e 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -1,1883 +1,1513 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
+
+#define ARITHM_MAT_DEPTH Values(CV_8U, CV_16U, CV_32F, CV_64F)
 
 //////////////////////////////////////////////////////////////////////
 // Merge
 
-GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH, Values(2, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
-
-    std::vector<cv::gpu::GpuMat> src(channels);
+    std::vector<cv::gpu::GpuMat> d_src(channels);
     for (int i = 0; i < channels; ++i)
-        src[i] = cv::gpu::GpuMat(size, depth, cv::Scalar::all(i));
+        d_src[i] = cv::gpu::GpuMat(size, depth, cv::Scalar::all(i));
 
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::merge(src, dst);
+    cv::gpu::merge(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::merge(src, dst);
+        cv::gpu::merge(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Merge, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    testing::Values<Channels>(2, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
 // Split
 
-GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH, Values(2, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::gpu::GpuMat src(size, CV_MAKE_TYPE(depth, channels), cv::Scalar(1, 2, 3, 4));
+    cv::gpu::GpuMat d_src(size, CV_MAKE_TYPE(depth, channels), cv::Scalar(1, 2, 3, 4));
 
-    std::vector<cv::gpu::GpuMat> dst;
+    std::vector<cv::gpu::GpuMat> d_dst;
 
-    cv::gpu::split(src, dst);
+    cv::gpu::split(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::split(src, dst);
+        cv::gpu::split(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Split, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    testing::Values<Channels>(2, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
-// Add_Mat
+// AddMat
 
-GPU_PERF_TEST(Add_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0.0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0.0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::add(src1, src2, dst);
+    cv::gpu::add(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::add(src1, src2, dst);
+        cv::gpu::add(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Add_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Add_Scalar
+// AddScalar
 
-GPU_PERF_TEST(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar s(1, 2, 3, 4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::add(src, s, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::add(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::add(src, s, dst);
+        cv::gpu::add(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Add_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Subtract_Mat
+// SubtractMat
 
-GPU_PERF_TEST(Subtract_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0.0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0.0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::subtract(src1, src2, dst);
+    cv::gpu::subtract(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::subtract(src1, src2, dst);
+        cv::gpu::subtract(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Subtract_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Subtract_Scalar
+// SubtractScalar
 
-GPU_PERF_TEST(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar s(1, 2, 3, 4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::subtract(src, s, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::subtract(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::subtract(src, s, dst);
+        cv::gpu::subtract(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Subtract_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Multiply_Mat
+// MultiplyMat
 
-GPU_PERF_TEST(Multiply_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0.0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0.0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::multiply(src1, src2, dst);
+    cv::gpu::multiply(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::multiply(src1, src2, dst);
+        cv::gpu::multiply(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Multiply_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Multiply_Scalar
+// MultiplyScalar
 
-GPU_PERF_TEST(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar s(1, 2, 3, 4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::multiply(src, s, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::multiply(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::multiply(src, s, dst);
+        cv::gpu::multiply(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Multiply_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Divide_Mat
+// DivideMat
 
-GPU_PERF_TEST(Divide_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0.0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0.0, 100.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::divide(src1, src2, dst);
+    cv::gpu::divide(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::divide(src1, src2, dst);
+        cv::gpu::divide(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Divide_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Divide_Scalar
+// DivideScalar
 
-GPU_PERF_TEST(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar s(1, 2, 3, 4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::divide(src, s, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::divide(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::divide(src, s, dst);
+        cv::gpu::divide(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// Divide_Scalar_Inv
+// DivideScalarInv
 
-GPU_PERF_TEST(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    double s = 100.0;
 
-    cv::gpu::GpuMat src(src_host);
-    double scale = 100.0;
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::divide(scale, src, dst);
+    cv::gpu::divide(s, d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::divide(scale, src, dst);
+        cv::gpu::divide(s, d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar_Inv, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// AbsDiff_Mat
+// AbsDiffMat
 
-GPU_PERF_TEST(AbsDiff_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0.0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0.0, 100.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::absdiff(src1, src2, dst);
+    cv::gpu::absdiff(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::absdiff(src1, src2, dst);
+        cv::gpu::absdiff(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
-// AbsDiff_Scalar
+// AbsDiffScalar
 
-GPU_PERF_TEST(AbsDiff_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar s(1, 2, 3, 4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::absdiff(src, s, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::absdiff(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::absdiff(src, s, dst);
+        cv::gpu::absdiff(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
 // Abs
 
-GPU_PERF_TEST(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::abs(src, dst);
+    cv::gpu::abs(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::abs(src, dst);
+        cv::gpu::abs(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Abs, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // Sqr
 
-GPU_PERF_TEST(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::sqr(src, dst);
+    cv::gpu::sqr(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::sqr(src, dst);
+        cv::gpu::sqr(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Sqr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // Sqrt
 
-GPU_PERF_TEST(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::sqrt(src, dst);
+    cv::gpu::sqrt(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::sqrt(src, dst);
+        cv::gpu::sqrt(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Sqrt, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // Log
 
-GPU_PERF_TEST(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src, 1.0, 255.0);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 1.0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::log(src, dst);
+    cv::gpu::log(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::log(src, dst);
+        cv::gpu::log(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Log, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // Exp
 
-GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 1.0, 10.0);
+    cv::Mat src(size, depth);
+    fillRandom(src, 1.0, 10.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::exp(src, dst);
+    cv::gpu::exp(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::exp(src, dst);
+        cv::gpu::exp(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Exp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // Pow
 
-GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Power, cv::Size, MatDepth, double);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S, CV_32F), Values(0.3, 2.0, 2.4)))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    double power = GET_PARAM(2);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 1.0, 10.0);
+    cv::Mat src(size, depth);
+    fillRandom(src, 1.0, 10.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::pow(src, 2.3, dst);
+    cv::gpu::pow(d_src, power, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::pow(src, 2.3, dst);
+        cv::gpu::pow(d_src, power, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Pow, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
-// Compare_Mat
+// CompareMat
 
 CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)
-#define ALL_CMP_CODES testing::Values(CmpCode(cv::CMP_EQ), CmpCode(cv::CMP_NE), CmpCode(cv::CMP_GT), CmpCode(cv::CMP_GE), CmpCode(cv::CMP_LT), CmpCode(cv::CMP_LE))
+#define ALL_CMP_CODES ValuesIn(CmpCode::all())
 
-GPU_PERF_TEST(Compare_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CmpCode);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int cmp_code = GET_PARAM(3);
+PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH, ALL_CMP_CODES))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int cmp_code = GET_PARAM(2);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::compare(src1, src2, dst, cmp_code);
+    cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
 
     TEST_CYCLE()
     {
-        cv::gpu::compare(src1, src2, dst, cmp_code);
+        cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Compare_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    ALL_CMP_CODES));
-
 //////////////////////////////////////////////////////////////////////
-// Compare_Scalar
+// CompareScalar
 
-GPU_PERF_TEST(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)
+PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEPTH, ALL_CMP_CODES))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int cmp_code = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int cmp_code = GET_PARAM(3);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 100.0);
+    cv::Scalar s = cv::Scalar::all(100);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Scalar s = cv::Scalar::all(50);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::compare(src, s, dst, cmp_code);
+    cv::gpu::compare(d_src, s, d_dst, cmp_code);
 
     TEST_CYCLE()
     {
-        cv::gpu::compare(src, s, dst, cmp_code);
+        cv::gpu::compare(d_src, s, d_dst, cmp_code);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Compare_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    ALL_CMP_CODES));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_Not
+// BitwiseNot
 
-GPU_PERF_TEST(Bitwise_Not, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::bitwise_not(src, dst);
+    cv::gpu::bitwise_not(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_not(src, dst);
+        cv::gpu::bitwise_not(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_Not, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_And_Mat
+// BitwiseAndMat
 
-GPU_PERF_TEST(Bitwise_And_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_and(src1, src2, dst);
+    cv::gpu::bitwise_and(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_and(src1, src2, dst);
+        cv::gpu::bitwise_and(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_And_Scalar
+// BitwiseAndScalar
 
-GPU_PERF_TEST(Bitwise_And_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 100.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
+
+    cv::Scalar s = cv::Scalar::all(100);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Scalar s = cv::Scalar(50, 50, 50, 50);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_and(src, s, dst);
+    cv::gpu::bitwise_and(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_and(src, s, dst);
+        cv::gpu::bitwise_and(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),
-    testing::Values<Channels>(1, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_Or_Mat
+// BitwiseOrMat
 
-GPU_PERF_TEST(Bitwise_Or_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_or(src1, src2, dst);
+    cv::gpu::bitwise_or(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_or(src1, src2, dst);
+        cv::gpu::bitwise_or(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_Or_Scalar
+// BitwiseOrScalar
 
-GPU_PERF_TEST(Bitwise_Or_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 100.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
+
+    cv::Scalar s = cv::Scalar::all(100);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Scalar s = cv::Scalar(50, 50, 50, 50);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_or(src, s, dst);
+    cv::gpu::bitwise_or(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_or(src, s, dst);
+        cv::gpu::bitwise_or(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),
-    testing::Values<Channels>(1, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_Xor_Mat
+// BitwiseXorMat
 
-GPU_PERF_TEST(Bitwise_Xor_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 100.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 100.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_xor(src1, src2, dst);
+    cv::gpu::bitwise_xor(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_xor(src1, src2, dst);
+        cv::gpu::bitwise_xor(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));
-
 //////////////////////////////////////////////////////////////////////
-// Bitwise_Xor_Scalar
+// BitwiseXorScalar
 
-GPU_PERF_TEST(Bitwise_Xor_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 100.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
+
+    cv::Scalar s = cv::Scalar::all(100);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Scalar s = cv::Scalar(50, 50, 50, 50);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::bitwise_xor(src, s, dst);
+    cv::gpu::bitwise_xor(d_src, s, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::bitwise_xor(src, s, dst);
+        cv::gpu::bitwise_xor(d_src, s, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),
-    testing::Values<Channels>(1, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
 // RShift
 
-GPU_PERF_TEST(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::rshift(src, val, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::rshift(d_src, val, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::rshift(src, val, dst);
+        cv::gpu::rshift(d_src, val, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, RShift, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),
-    testing::Values<Channels>(1, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
 // LShift
 
-GPU_PERF_TEST(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)
+PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32S), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar_<int> val = cv::Scalar_<int>::all(4);
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::lshift(src, val, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::lshift(d_src, val, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::lshift(src, val, dst);
+        cv::gpu::lshift(d_src, val, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, LShift, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),
-    testing::Values<Channels>(1, 3, 4)));
-
 //////////////////////////////////////////////////////////////////////
-// Min_Mat
+// MinMat
 
-GPU_PERF_TEST(Min_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 255.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 255.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::min(src1, src2, dst);
+    cv::gpu::min(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::min(src1, src2, dst);
+        cv::gpu::min(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Min_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
-// Min_Scalar
+// MinScalar
 
-GPU_PERF_TEST(Min_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 255.0);
-
-    cv::gpu::GpuMat src(src_host);
     double val = 50.0;
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::min(src, val, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::min(d_src, val, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::min(src, val, dst);
+        cv::gpu::min(d_src, val, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Min_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
-// Max_Mat
+// MaxMat
 
-GPU_PERF_TEST(Max_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src1_host(size, depth);
-    fill(src1_host, 0, 255.0);
+    cv::Mat src1(size, depth);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth);
-    fill(src2_host, 0, 255.0);
+    cv::Mat src2(size, depth);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::max(src1, src2, dst);
+    cv::gpu::max(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::max(src1, src2, dst);
+        cv::gpu::max(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Max_Mat, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
-// Max_Scalar
+// MaxScalar
 
-GPU_PERF_TEST(Max_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 255.0);
-
-    cv::gpu::GpuMat src(src_host);
     double val = 50.0;
-    cv::gpu::GpuMat dst;
 
-    cv::gpu::max(src, val, dst);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::max(d_src, val, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::max(src, val, dst);
+        cv::gpu::max(d_src, val, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Max_Scalar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));
-
 //////////////////////////////////////////////////////////////////////
 // AddWeighted
 
-GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, MatDepth)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_3Depth, cv::Size, MatDepth, MatDepth, MatDepth);
 
-    cv::Size size = GET_PARAM(1);
-    int depth1 = GET_PARAM(2);
-    int depth2 = GET_PARAM(3);
-    int dst_depth = GET_PARAM(4);
+PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F),
+    Values(CV_8U, CV_16U, CV_32F, CV_64F),
+    Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth1 = GET_PARAM(1);
+    int depth2 = GET_PARAM(2);
+    int dst_depth = GET_PARAM(3);
 
-    cv::Mat src1_host(size, depth1);
-    fill(src1_host, 0, 100.0);
+    cv::Mat src1(size, depth1);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, depth2);
-    fill(src2_host, 0, 100.0);
+    cv::Mat src2(size, depth2);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
+    cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
 
     TEST_CYCLE()
     {
-        cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
+        cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, AddWeighted, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
 // 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))
+#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)
 
-GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int flags = GET_PARAM(3);
+PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
+    Values(cv::Size(512, 512), cv::Size(1024, 1024)),
+    Values(CV_32FC1, CV_32FC2, CV_64FC1, CV_64FC2),
+    ALL_GEMM_FLAGS))
+{
+    declare.time(5.0);
 
-    cv::Mat src1_host(size, type);
-    fill(src1_host, 0.0, 10.0);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int flags = GET_PARAM(2);
 
-    cv::Mat src2_host(size, type);
-    fill(src2_host, 0.0, 10.0);
+    cv::Mat src1(size, type);
+    fillRandom(src1);
 
-    cv::Mat src3_host(size, type);
-    fill(src3_host, 0.0, 10.0);
+    cv::Mat src2(size, type);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat src3(src3_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src3(size, type);
+    fillRandom(src3);
 
-    cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_src3(src3);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(5.0);
+    cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
 
     TEST_CYCLE()
     {
-        cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
+        cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, GEMM, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(cv::Size(512, 512), cv::Size(1024, 1024)),
-    testing::Values<MatType>(CV_32FC1, CV_32FC2, CV_64FC1, CV_64FC2),
-    ALL_GEMM_FLAGS));
-
-#endif
 //////////////////////////////////////////////////////////////////////
 // Transpose
 
-GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 100.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::transpose(src, dst);
+    cv::gpu::transpose(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::transpose(src, dst);
+        cv::gpu::transpose(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Transpose, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)));
-
 //////////////////////////////////////////////////////////////////////
 // Flip
 
 enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
 CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
-#define ALL_FLIP_CODES testing::Values(FlipCode(FLIP_BOTH), FlipCode(FLIP_X), FlipCode(FLIP_Y))
+#define ALL_FLIP_CODES ValuesIn(FlipCode::all())
 
-GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, int, FlipCode);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    ALL_FLIP_CODES))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int flipCode = GET_PARAM(3);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 100.0);
+    int type = CV_MAKE_TYPE(depth, channels);
+
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::flip(src, dst, flipCode);
+    cv::gpu::flip(d_src, d_dst, flipCode);
 
     TEST_CYCLE()
     {
-        cv::gpu::flip(src, dst, flipCode);
+        cv::gpu::flip(d_src, d_dst, flipCode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Flip, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),
-    ALL_FLIP_CODES));
-
 //////////////////////////////////////////////////////////////////////
-// LUT_OneChannel
+// LutOneChannel
 
-GPU_PERF_TEST(LUT_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8UC1, CV_8UC3)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 100.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     cv::Mat lut(1, 256, CV_8UC1);
-    fill(lut, 0.0, 100.0);
+    fillRandom(lut);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::LUT(src, lut, dst);
+    cv::gpu::LUT(d_src, lut, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::LUT(src, lut, dst);
+        cv::gpu::LUT(d_src, lut, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, LUT_OneChannel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC3)));
-
 //////////////////////////////////////////////////////////////////////
-// LUT_MultiChannel
+// LutMultiChannel
 
-GPU_PERF_TEST(LUT_MultiChannel, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values<MatType>(CV_8UC3)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 100.0);
+    cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));
+    fillRandom(lut);
 
-    cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src_host.channels()));
-    fill(lut, 0.0, 100.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::LUT(src, lut, dst);
+    cv::gpu::LUT(d_src, lut, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::LUT(src, lut, dst);
+        cv::gpu::LUT(d_src, lut, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, LUT_MultiChannel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC3)));
-
 //////////////////////////////////////////////////////////////////////
-// Magnitude_Complex
+// MagnitudeComplex
 
-GPU_PERF_TEST(Magnitude_Complex, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_32FC2);
-    fill(src_host, -100.0, 100.0);
+    cv::Mat src(size, CV_32FC2);
+    fillRandom(src, -100.0, 100.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::magnitude(src, dst);
+    cv::gpu::magnitude(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::magnitude(src, dst);
+        cv::gpu::magnitude(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Magnitude_Complex, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
-// Magnitude_Sqr_Complex
+// MagnitudeSqrComplex
 
-GPU_PERF_TEST(Magnitude_Sqr_Complex, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_32FC2);
-    fill(src_host, -100.0, 100.0);
+    cv::Mat src(size, CV_32FC2);
+    fillRandom(src, -100.0, 100.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::magnitudeSqr(src, dst);
+    cv::gpu::magnitudeSqr(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::magnitudeSqr(src, dst);
+        cv::gpu::magnitudeSqr(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Magnitude_Sqr_Complex, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Magnitude
 
-GPU_PERF_TEST(Magnitude, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GetParam();
 
-    cv::Size size = GET_PARAM(1);
+    cv::Mat src1(size, CV_32FC1);
+    fillRandom(src1, -100.0, 100.0);
 
-    cv::Mat src1_host(size, CV_32FC1);
-    fill(src1_host, -100.0, 100.0);
+    cv::Mat src2(size, CV_32FC1);
+    fillRandom(src2, -100.0, 100.0);
 
-    cv::Mat src2_host(size, CV_32FC1);
-    fill(src2_host, -100.0, 100.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::magnitude(src1, src2, dst);
+    cv::gpu::magnitude(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::magnitude(src1, src2, dst);
+        cv::gpu::magnitude(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Magnitude, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
-// Magnitude_Sqr
+// MagnitudeSqr
 
-GPU_PERF_TEST(Magnitude_Sqr, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GetParam();
 
-    cv::Size size = GET_PARAM(1);
+    cv::Mat src1(size, CV_32FC1);
+    fillRandom(src1, -100.0, 100.0);
 
-    cv::Mat src1_host(size, CV_32FC1);
-    fill(src1_host, -100.0, 100.0);
+    cv::Mat src2(size, CV_32FC1);
+    fillRandom(src2, -100.0, 100.0);
 
-    cv::Mat src2_host(size, CV_32FC1);
-    fill(src2_host, -100.0, 100.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::magnitudeSqr(src1, src2, dst);
+    cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::magnitudeSqr(src1, src2, dst);
+        cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Magnitude_Sqr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Phase
 
-IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)
+DEF_PARAM_TEST(Sz_AngleInDegrees, cv::Size, bool);
 
-GPU_PERF_TEST(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)
+PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool()))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    bool angleInDegrees = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    bool angleInDegrees = GET_PARAM(2);
+    cv::Mat src1(size, CV_32FC1);
+    fillRandom(src1, -100.0, 100.0);
 
-    cv::Mat src1_host(size, CV_32FC1);
-    fill(src1_host, -100.0, 100.0);
+    cv::Mat src2(size, CV_32FC1);
+    fillRandom(src2, -100.0, 100.0);
 
-    cv::Mat src2_host(size, CV_32FC1);
-    fill(src2_host, -100.0, 100.0);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::phase(src1, src2, dst, angleInDegrees);
+    cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
 
     TEST_CYCLE()
     {
-        cv::gpu::phase(src1, src2, dst, angleInDegrees);
+        cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Phase, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<AngleInDegrees>(false, true)));
-
 //////////////////////////////////////////////////////////////////////
 // CartToPolar
 
-GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)
+PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES, Bool()))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    bool angleInDegrees = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    bool angleInDegrees = GET_PARAM(2);
+    cv::Mat src1(size, CV_32FC1);
+    fillRandom(src1, -100.0, 100.0);
 
-    cv::Mat src1_host(size, CV_32FC1);
-    fill(src1_host, -100.0, 100.0);
+    cv::Mat src2(size, CV_32FC1);
+    fillRandom(src2, -100.0, 100.0);
 
-    cv::Mat src2_host(size, CV_32FC1);
-    fill(src2_host, -100.0, 100.0);
+    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 src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat magnitude;
-    cv::gpu::GpuMat angle;
-
-    cv::gpu::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
+    cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
 
     TEST_CYCLE()
     {
-        cv::gpu::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
+        cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, CartToPolar, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<AngleInDegrees>(false, true)));
-
 //////////////////////////////////////////////////////////////////////
 // PolarToCart
 
-GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)
+PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES, Bool()))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    bool angleInDegrees = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    bool angleInDegrees = GET_PARAM(2);
+    cv::Mat magnitude(size, CV_32FC1);
+    fillRandom(magnitude, 0.0, 100.0);
 
-    cv::Mat magnitude_host(size, CV_32FC1);
-    fill(magnitude_host, 0.0, 100.0);
+    cv::Mat angle(size, CV_32FC1);
+    fillRandom(angle, 0.0, angleInDegrees ? 360.0 : 2 * CV_PI);
 
-    cv::Mat angle_host(size, CV_32FC1);
-    fill(angle_host, 0.0, angleInDegrees ? 360.0 : 2 * CV_PI);
+    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 magnitude(magnitude_host);
-    cv::gpu::GpuMat angle(angle_host);
-    cv::gpu::GpuMat x;
-    cv::gpu::GpuMat y;
-
-    cv::gpu::polarToCart(magnitude, angle, x, y, angleInDegrees);
+    cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
 
     TEST_CYCLE()
     {
-        cv::gpu::polarToCart(magnitude, angle, x, y, angleInDegrees);
+        cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, PolarToCart, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<AngleInDegrees>(false, true)));
-
 //////////////////////////////////////////////////////////////////////
 // MeanStdDev
 
-GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GetParam();
 
-    cv::Size size = GET_PARAM(1);
+    cv::Mat src(size, CV_8UC1);
+    fillRandom(src);
 
-    cv::Mat src_host(size, CV_8UC1);
-    fill(src_host, 0.0, 255.0);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar mean;
     cv::Scalar stddev;
-    cv::gpu::GpuMat buf;
 
-    cv::gpu::meanStdDev(src, mean, stddev, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::meanStdDev(src, mean, stddev, buf);
+        cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, MeanStdDev, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Norm
 
-GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormType)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int normType = GET_PARAM(3);
+PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32S, CV_32F),
+    Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int normType = GET_PARAM(2);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     double dst;
-    cv::gpu::GpuMat buf;
 
-    dst = cv::gpu::norm(src, normType, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    dst = cv::gpu::norm(d_src, normType, d_buf);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::norm(src, normType, buf);
+        dst = cv::gpu::norm(d_src, normType, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Norm, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S, CV_32F),
-    testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));
-
 //////////////////////////////////////////////////////////////////////
 // NormDiff
 
-GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Norm, cv::Size, NormType);
 
-    cv::Size size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
+PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
+{
+    cv::Size size = GET_PARAM(0);
+    int normType = GET_PARAM(1);
 
-    cv::Mat src1_host(size, CV_8UC1);
-    fill(src1_host, 0.0, 255.0);
+    cv::Mat src1(size, CV_8UC1);
+    fillRandom(src1);
 
-    cv::Mat src2_host(size, CV_8UC1);
-    fill(src2_host, 0.0, 255.0);
+    cv::Mat src2(size, CV_8UC1);
+    fillRandom(src2);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
     double dst;
 
-    dst = cv::gpu::norm(src1, src2, normType);
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+
+    dst = cv::gpu::norm(d_src1, d_src2, normType);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::norm(src1, src2, normType);
+        dst = cv::gpu::norm(d_src1, d_src2, normType);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, NormDiff, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));
-
 //////////////////////////////////////////////////////////////////////
 // Sum
 
-GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar dst;
-    cv::gpu::GpuMat buf;
 
-    dst = cv::gpu::sum(src, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    dst = cv::gpu::sum(d_src, d_buf);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::sum(src, buf);
+        dst = cv::gpu::sum(d_src, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Sum, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
-
 //////////////////////////////////////////////////////////////////////
-// Sum_Abs
+// SumAbs
 
-GPU_PERF_TEST(Sum_Abs, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar dst;
-    cv::gpu::GpuMat buf;
 
-    dst = cv::gpu::absSum(src, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    dst = cv::gpu::absSum(d_src, d_buf);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::absSum(src, buf);
+        dst = cv::gpu::absSum(d_src, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Sum_Abs, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
-
 //////////////////////////////////////////////////////////////////////
-// Sum_Sqr
+// SumSqr
 
-GPU_PERF_TEST(Sum_Sqr, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values<MatDepth>(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar dst;
-    cv::gpu::GpuMat buf;
 
-    dst = cv::gpu::sqrSum(src, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    dst = cv::gpu::sqrSum(d_src, d_buf);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::sqrSum(src, buf);
+        dst = cv::gpu::sqrSum(d_src, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Sum_Sqr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
-
 //////////////////////////////////////////////////////////////////////
 // MinMax
 
-GPU_PERF_TEST(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
     double minVal, maxVal;
-    cv::gpu::GpuMat buf;
 
-    cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);
+        cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, MinMax, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
 // MinMaxLoc
 
-GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 255.0);
-
-    cv::gpu::GpuMat src(src_host);
     double minVal, maxVal;
     cv::Point minLoc, maxLoc;
-    cv::gpu::GpuMat valbuf, locbuf;
 
-    cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_valbuf, d_locbuf;
+
+    cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
 
     TEST_CYCLE()
     {
-        cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);
+        cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, MinMaxLoc, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
 // CountNonZero
 
-GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0.0, 1.5);
-
-    cv::gpu::GpuMat src(src_host);
     int dst;
-    cv::gpu::GpuMat buf;
 
-    dst = cv::gpu::countNonZero(src, buf);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_buf;
+
+    dst = cv::gpu::countNonZero(d_src, d_buf);
 
     TEST_CYCLE()
     {
-        dst = cv::gpu::countNonZero(src, buf);
+        dst = cv::gpu::countNonZero(d_src, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, CountNonZero, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));
-
 //////////////////////////////////////////////////////////////////////
 // Reduce
 
 CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
-#define ALL_REDUCE_CODES testing::Values<ReduceCode>(CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
+#define ALL_REDUCE_CODES ValuesIn(ReduceCode::all())
 
 enum {Rows = 0, Cols = 1};
 CV_ENUM(ReduceDim, Rows, Cols)
+#define ALL_REDUCE_DIMS ValuesIn(ReduceDim::all())
 
-GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, ReduceDim)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, int, ReduceCode, ReduceDim);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int channels = GET_PARAM(3);
-    int reduceOp = GET_PARAM(4);
-    int dim = GET_PARAM(5);
+PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_16S, CV_32F),
+    Values(1, 2, 3, 4),
+    ALL_REDUCE_CODES,
+    ALL_REDUCE_DIMS))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
+    int reduceOp = GET_PARAM(3);
+    int dim = GET_PARAM(4);
 
     int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 10.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::reduce(src, dst, dim, reduceOp);
+    cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
 
     TEST_CYCLE()
     {
-        cv::gpu::reduce(src, dst, dim, reduceOp);
+        cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Core, Reduce, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16U, CV_16S, CV_32F),
-    testing::Values<Channels>(1, 2, 3, 4),
-    ALL_REDUCE_CODES,
-    testing::Values(ReduceDim(Rows), ReduceDim(Cols))));
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp
index 8a81860176..ef9612b549 100644
--- a/modules/gpu/perf/perf_features2d.cpp
+++ b/modules/gpu/perf/perf_features2d.cpp
@@ -1,209 +1,179 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // SURF
 
-GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST_1(Image, string);
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.jpg"))
+{
+    declare.time(2.0);
 
-    cv::gpu::SURF_GPU surf;
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+    cv::gpu::SURF_GPU d_surf;
 
-    surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
+    cv::gpu::GpuMat d_img(img);
+    cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    declare.time(2.0);
+    d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
     TEST_CYCLE()
     {
-        surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, SURF, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // FAST
 
-GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.jpg"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    cv::gpu::FAST_GPU d_fast(20);
 
-    cv::gpu::FAST_GPU fast(20);
+    cv::gpu::GpuMat d_img(img);
+    cv::gpu::GpuMat d_keypoints;
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints;
-
-    fast(img, cv::gpu::GpuMat(), keypoints);
+    d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
 
     TEST_CYCLE()
     {
-        fast(img, cv::gpu::GpuMat(), keypoints);
+        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, FAST, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // ORB
 
-GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.jpg"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    cv::gpu::ORB_GPU d_orb(4000);
 
-    cv::gpu::ORB_GPU orb(4000);
+    cv::gpu::GpuMat d_img(img);
+    cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+    d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
     TEST_CYCLE()
     {
-        orb(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, ORB, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_match
+// BFMatch
 
-IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
+DEF_PARAM_TEST(DescSize_Norm, int, NormType);
 
-GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, DescriptorSize, NormType)
+PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(3.0);
 
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
+    int desc_size = GET_PARAM(0);
+    int normType = GET_PARAM(1);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 10.0);
-
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 10.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance;
+    cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    matcher.matchSingle(query, train, trainIdx, distance);
+    cv::gpu::GpuMat d_query(query);
+    cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_trainIdx, d_distance;
 
-    declare.time(3.0);
+    d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 
     TEST_CYCLE()
     {
-        matcher.matchSingle(query, train, trainIdx, distance);
+        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_knnMatch
+// BFKnnMatch
 
-IMPLEMENT_PARAM_CLASS(K, int)
+DEF_PARAM_TEST(DescSize_K_Norm, int, int, NormType);
 
-GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, DescriptorSize, K, NormType)
+PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
+    Values(64, 128, 256),
+    Values(2, 3),
+    Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(3.0);
 
-    int desc_size = GET_PARAM(1);
-    int k = GET_PARAM(2);
-    int normType = GET_PARAM(3);
+    int desc_size = GET_PARAM(0);
+    int k = GET_PARAM(1);
+    int normType = GET_PARAM(2);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 10.0);
-
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 10.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance, allDist;
+    cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
+    cv::gpu::GpuMat d_query(query);
+    cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
 
-    declare.time(3.0);
+    d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
 
     TEST_CYCLE()
     {
-        matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
+        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(K(2), K(3)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_radiusMatch
+// BFRadiusMatch
 
-GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, DescriptorSize, NormType)
+PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(3.0);
 
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
+    int desc_size = GET_PARAM(0);
+    int normType = GET_PARAM(1);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 1.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query, 0.0, 1.0);
 
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 1.0);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train, 0.0, 1.0);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, nMatches, distance;
+    cv::gpu::GpuMat d_query(query);
+    cv::gpu::GpuMat d_train(train);
+    cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
 
-    matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
-
-    declare.time(3.0);
+    d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
 
     TEST_CYCLE()
     {
-        matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
+        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 0263e8063f..71dcd49e2b 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -1,308 +1,235 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // Blur
 
-IMPLEMENT_PARAM_CLASS(KernelSize, int)
+DEF_PARAM_TEST(Sz_Type_KernelSz, cv::Size, MatType, int);
 
-GPU_PERF_TEST(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), Values(3, 5, 7)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int ksize = GET_PARAM(2);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::blur(src, dst, cv::Size(ksize, ksize));
+    cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
 
     TEST_CYCLE()
     {
-        cv::gpu::blur(src, dst, cv::Size(ksize, ksize));
+        cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Blur, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7))));
-
 //////////////////////////////////////////////////////////////////////
 // Sobel
 
-GPU_PERF_TEST(Sobel, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int ksize = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
-
-    cv::gpu::Sobel(src, dst, -1, 1, 1, buf, ksize);
+    cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
 
     TEST_CYCLE()
     {
-        cv::gpu::Sobel(src, dst, -1, 1, 1, buf, ksize);
+        cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Sobel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
 //////////////////////////////////////////////////////////////////////
 // Scharr
 
-GPU_PERF_TEST(Scharr, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
-
-    cv::gpu::Scharr(src, dst, -1, 1, 0, buf);
+    cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::Scharr(src, dst, -1, 1, 0, buf);
+        cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Scharr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));
-
 //////////////////////////////////////////////////////////////////////
 // GaussianBlur
 
-GPU_PERF_TEST(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int ksize = GET_PARAM(2);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::GaussianBlur(src, dst, cv::Size(ksize, ksize), buf, 0.5);
+    cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
 
     TEST_CYCLE()
     {
-        cv::gpu::GaussianBlur(src, dst, cv::Size(ksize, ksize), buf, 0.5);
+        cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, GaussianBlur, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
 //////////////////////////////////////////////////////////////////////
 // Laplacian
 
-GPU_PERF_TEST(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 3)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int ksize = GET_PARAM(2);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::Laplacian(src, dst, -1, ksize);
+    cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
 
     TEST_CYCLE()
     {
-        cv::gpu::Laplacian(src, dst, -1, ksize);
+        cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Laplacian, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
-    testing::Values(KernelSize(1), KernelSize(3))));
-
 //////////////////////////////////////////////////////////////////////
 // Erode
 
-GPU_PERF_TEST(Erode, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::erode(src, dst, ker, buf);
+    cv::gpu::erode(d_src, d_dst, ker, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::erode(src, dst, ker, buf);
+        cv::gpu::erode(d_src, d_dst, ker, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Erode, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
-
 //////////////////////////////////////////////////////////////////////
 // Dilate
 
-GPU_PERF_TEST(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::dilate(src, dst, ker, buf);
+    cv::gpu::dilate(d_src, d_dst, ker, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::dilate(src, dst, ker, buf);
+        cv::gpu::dilate(d_src, d_dst, ker, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Dilate, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
-
 //////////////////////////////////////////////////////////////////////
 // MorphologyEx
 
 CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT)
-#define ALL_MORPH_OPS testing::Values(MorphOp(cv::MORPH_OPEN), MorphOp(cv::MORPH_CLOSE), MorphOp(cv::MORPH_GRADIENT), MorphOp(cv::MORPH_TOPHAT), MorphOp(cv::MORPH_BLACKHAT))
+#define ALL_MORPH_OPS ValuesIn(MorphOp::all())
 
-GPU_PERF_TEST(MorphologyEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int morphOp = GET_PARAM(3);
+PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), ALL_MORPH_OPS))
+{
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int morphOp = GET_PARAM(2);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf1;
-    cv::gpu::GpuMat buf2;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf1;
+    cv::gpu::GpuMat d_buf2;
 
-    cv::gpu::morphologyEx(src, dst, morphOp, ker, buf1, buf2);
+    cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
 
     TEST_CYCLE()
     {
-        cv::gpu::morphologyEx(src, dst, morphOp, ker, buf1, buf2);
+        cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, MorphologyEx, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
-    ALL_MORPH_OPS));
-
 //////////////////////////////////////////////////////////////////////
 // Filter2D
 
-GPU_PERF_TEST(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(3, 5, 7, 9, 11, 13, 15)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int ksize = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src_host(size, type);
-    fill(src_host, 0.0, 255.0);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     cv::Mat kernel(ksize, ksize, CV_32FC1);
-    fill(kernel, 0.0, 1.0);
+    fillRandom(kernel, 0.0, 1.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::filter2D(src, dst, -1, kernel);
+    cv::gpu::filter2D(d_src, d_dst, -1, kernel);
 
     TEST_CYCLE()
     {
-        cv::gpu::filter2D(src, dst, -1, kernel);
+        cv::gpu::filter2D(d_src, d_dst, -1, kernel);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filters, Filter2D, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 0dbcd34c65..a1614a79f3 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -1,188 +1,226 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // Remap
 
-GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
+enum{HALF_SIZE=0, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH};
+CV_ENUM(RemapMode, HALF_SIZE, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH);
+#define ALL_REMAP_MODES ValuesIn(RemapMode::all())
+
+void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode)
+{
+    for (int j = 0; j < map_x.rows; ++j)
+    {
+        for (int i = 0; i < map_x.cols; ++i)
+        {
+            switch (remapMode)
+            {
+            case HALF_SIZE:
+                if (i > map_x.cols*0.25 && i < map_x.cols*0.75 && j > map_x.rows*0.25 && j < map_x.rows*0.75)
+                {
+                    map_x.at<float>(j,i) = 2 * (i - map_x.cols * 0.25) + 0.5;
+                    map_y.at<float>(j,i) = 2 * (j - map_x.rows * 0.25) + 0.5;
+                }
+                else
+                {
+                    map_x.at<float>(j,i) = 0;
+                    map_y.at<float>(j,i) = 0;
+                }
+                break;
+            case UPSIDE_DOWN:
+                map_x.at<float>(j,i) = i;
+                map_y.at<float>(j,i) = map_x.rows - j;
+                break;
+            case REFLECTION_X:
+                map_x.at<float>(j,i) = map_x.cols - i;
+                map_y.at<float>(j,i) = j;
+                break;
+            case REFLECTION_BOTH:
+                map_x.at<float>(j,i) = map_x.cols - i;
+                map_y.at<float>(j,i) = map_x.rows - j;
+                break;
+            } // end of switch
+        }
+    }
+}
+
+DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border_Mode, cv::Size, MatDepth, int, Interpolation, BorderMode, RemapMode);
+
+PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
+    ALL_BORDER_MODES,
+    ALL_REMAP_MODES))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(3.0);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = GET_PARAM(3);
     int borderMode = GET_PARAM(4);
+    int remapMode = GET_PARAM(5);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat xmap_host(size, CV_32FC1);
-    fill(xmap_host, 0, size.width);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat ymap_host(size, CV_32FC1);
-    fill(ymap_host, 0, size.height);
+    cv::Mat xmap(size, CV_32FC1);
+    cv::Mat ymap(size, CV_32FC1);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat xmap(xmap_host);
-    cv::gpu::GpuMat ymap(ymap_host);
-    cv::gpu::GpuMat dst;
+    generateMap(xmap, ymap, remapMode);
 
-    cv::gpu::remap(src, dst, xmap, 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;
 
-    declare.time(3.0);
+    cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
 
     TEST_CYCLE()
     {
-        cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);
+        cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
-
 //////////////////////////////////////////////////////////////////////
 // Resize
 
-IMPLEMENT_PARAM_CLASS(Scale, double)
+DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Scale, cv::Size, MatDepth, int, Interpolation, double);
 
-GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)
+PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    ALL_INTERPOLATIONS,
+    Values(0.5, 0.3, 2.0)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(1.0);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = GET_PARAM(3);
     double f = GET_PARAM(4);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(1.0);
+    cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
 
     TEST_CYCLE()
     {
-        cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(
-    ALL_DEVICES,
+//////////////////////////////////////////////////////////////////////
+// ResizeArea
+
+DEF_PARAM_TEST(Sz_Depth_Cn_Scale, cv::Size, MatDepth, int, double);
+
+PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
     GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR),
-                    Interpolation(cv::INTER_CUBIC),   Interpolation(cv::INTER_AREA)),
-    testing::Values(Scale(0.5), Scale(0.3), Scale(2.0))));
-
-GPU_PERF_TEST(ResizeArea, cv::gpu::DeviceInfo, cv::Size, MatType, Scale)
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    Values(0.2, 0.1, 0.05)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(1.0);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = cv::INTER_AREA;
     double f = GET_PARAM(3);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(1.0);
+    cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
 
     TEST_CYCLE()
     {
-        cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, ResizeArea, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(perf::sz1080p/*, cv::Size(4096, 2048)*/),
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Scale(0.2),Scale(0.1),Scale(0.05))));
-
 //////////////////////////////////////////////////////////////////////
 // WarpAffine
 
-GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border, cv::Size, MatDepth, int, Interpolation, BorderMode);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
+    ALL_BORDER_MODES))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = GET_PARAM(3);
     int borderMode = GET_PARAM(4);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     const double aplha = CV_PI / 4;
     double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},
                          {std::sin(aplha),  std::cos(aplha), 0}};
     cv::Mat M(2, 3, CV_64F, (void*) mat);
 
-    cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode);
+    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(src, dst, M, size, interpolation, borderMode);
+        cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
 //////////////////////////////////////////////////////////////////////
 // WarpPerspective
 
-GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
+PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
+    ALL_BORDER_MODES))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = GET_PARAM(3);
     int borderMode = GET_PARAM(4);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, type);
+    fillRandom(src);
 
     const double aplha = CV_PI / 4;
     double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},
@@ -190,1160 +228,958 @@ GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpola
                          {0.0,              0.0,             1.0}};
     cv::Mat M(3, 3, CV_64F, (void*) mat);
 
-    cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode);
+    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(src, dst, M, size, interpolation, borderMode);
+        cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
 //////////////////////////////////////////////////////////////////////
 // CopyMakeBorder
 
-GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)
+DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, int, BorderMode);
+
+PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    ALL_BORDER_MODES))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
+    int borderMode = GET_PARAM(3);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int borderType = GET_PARAM(3);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);
+    cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
 
     TEST_CYCLE()
     {
-        cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);
+        cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
 //////////////////////////////////////////////////////////////////////
 // Threshold
 
 CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
-#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
+#define ALL_THRESH_OPS ValuesIn(ThreshOp::all())
 
-GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int threshOp = GET_PARAM(3);
+PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F),
+    ALL_THRESH_OPS))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int threshOp = GET_PARAM(2);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);
+    cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
 
     TEST_CYCLE()
     {
-        cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);
+        cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),
-    ALL_THRESH_OPS));
-
 //////////////////////////////////////////////////////////////////////
 // Integral
 
-GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_8UC1);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, CV_8UC1);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::integralBuffered(src, dst, buf);
+    cv::gpu::integralBuffered(d_src, d_dst, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::integralBuffered(src, dst, buf);
+        cv::gpu::integralBuffered(d_src, d_dst, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
-// Integral_Sqr
+// IntegralSqr
 
-GPU_PERF_TEST(Integral_Sqr, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_8UC1);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, CV_8UC1);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::sqrIntegral(src, dst);
+    cv::gpu::sqrIntegral(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::sqrIntegral(src, dst);
+        cv::gpu::sqrIntegral(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Integral_Sqr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
-// HistEven_OneChannel
+// HistEvenC1
 
-GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, depth);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, depth);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat hist;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_hist;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::histEven(src, hist, buf, 30, 0, 180);
+    cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
 
     TEST_CYCLE()
     {
-        cv::gpu::histEven(src, hist, buf, 30, 0, 180);
+        cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));
-
 //////////////////////////////////////////////////////////////////////
-// HistEven_FourChannel
+// HistEvenC4
 
-GPU_PERF_TEST(HistEven_FourChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
 
-    cv::Mat src_host(size, CV_MAKE_TYPE(depth, 4));
-    fill(src_host, 0, 255);
+    cv::Mat src(size, CV_MAKE_TYPE(depth, 4));
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat hist[4];
-    cv::gpu::GpuMat buf;
     int histSize[] = {30, 30, 30, 30};
     int lowerLevel[] = {0, 0, 0, 0};
     int upperLevel[] = {180, 180, 180, 180};
 
-    cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_hist[4];
+    cv::gpu::GpuMat d_buf;
+
+    cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
 
     TEST_CYCLE()
     {
-        cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);
+        cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_FourChannel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));
-
 //////////////////////////////////////////////////////////////////////
 // CalcHist
 
-GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_8UC1);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, CV_8UC1);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat hist;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_hist;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::calcHist(src, hist, buf);
+    cv::gpu::calcHist(d_src, d_hist, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::calcHist(src, hist, buf);
+        cv::gpu::calcHist(d_src, d_hist, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // EqualizeHist
 
-GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GetParam();
 
-    cv::Size size = GET_PARAM(1);
+    cv::Mat src(size, CV_8UC1);
+    fillRandom(src);
 
-    cv::Mat src_host(size, CV_8UC1);
-    fill(src_host, 0, 255);
-
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat hist;
-    cv::gpu::GpuMat 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(src, dst, hist, buf);
+    cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::equalizeHist(src, dst, hist, buf);
+        cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // ColumnSum
 
-GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_32FC1);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, CV_32FC1);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::columnSum(src, dst);
+    cv::gpu::columnSum(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::columnSum(src, dst);
+        cv::gpu::columnSum(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Canny
 
-IMPLEMENT_PARAM_CLASS(AppertureSize, int)
-IMPLEMENT_PARAM_CLASS(L2gradient, bool)
+DEF_PARAM_TEST(Image_AppertureSz_L2gradient, string, int, bool);
 
-GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)
+PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
+    Values("perf/800x600.jpg", "perf/1280x1024.jpg", "perf/1680x1050.jpg"),
+    Values(3, 5),
+    Bool()))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
+    string fileName = GET_PARAM(0);
     int apperture_size = GET_PARAM(1);
     bool useL2gradient = GET_PARAM(2);
 
-    cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image_host.empty());
+    cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-    cv::gpu::GpuMat image(image_host);
-    cv::gpu::GpuMat dst;
-    cv::gpu::CannyBuf buf;
+    cv::gpu::GpuMat d_image(image);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::CannyBuf d_buf;
 
-    cv::gpu::Canny(image, buf, 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(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient);
+        cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(AppertureSize(3), AppertureSize(5)),
-    testing::Values(L2gradient(false), L2gradient(true))));
-
 //////////////////////////////////////////////////////////////////////
 // MeanShiftFiltering
 
-GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)
+DEF_PARAM_TEST_1(Image, string);
+
+PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/cones.png"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(5.0);
 
-    cv::Mat img = readImage("gpu/meanshift/cones.png");
+    cv::Mat img = readImage(GetParam());
     ASSERT_FALSE(img.empty());
 
     cv::Mat rgba;
     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat src(rgba);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(rgba);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::meanShiftFiltering(src, dst, 50, 50);
-
-    declare.time(5.0);
+    cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
 
     TEST_CYCLE()
     {
-        cv::gpu::meanShiftFiltering(src, dst, 50, 50);
+        cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // MeanShiftProc
 
-GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.png"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(5.0);
 
-    cv::Mat img = readImage("gpu/meanshift/cones.png");
+    cv::Mat img = readImage(GetParam());
     ASSERT_FALSE(img.empty());
 
     cv::Mat rgba;
     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat src(rgba);
-    cv::gpu::GpuMat dstr;
-    cv::gpu::GpuMat dstsp;
-
-    cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);
+    cv::gpu::GpuMat d_src(rgba);
+    cv::gpu::GpuMat d_dstr;
+    cv::gpu::GpuMat d_dstsp;
 
-    declare.time(5.0);
+    cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
 
     TEST_CYCLE()
     {
-        cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);
+        cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // MeanShiftSegmentation
 
-GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/cones.png"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(5.0);
 
-    cv::Mat img = readImage("gpu/meanshift/cones.png");
+    cv::Mat img = readImage(GetParam());
     ASSERT_FALSE(img.empty());
 
     cv::Mat rgba;
     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat src(rgba);
     cv::Mat dst;
 
-    meanShiftSegmentation(src, dst, 10, 10, 20);
+    cv::gpu::GpuMat d_src(rgba);
 
-    declare.time(5.0);
+    cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
 
     TEST_CYCLE()
     {
-        meanShiftSegmentation(src, dst, 10, 10, 20);
+        cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // BlendLinear
 
-GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_32F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat img1_host(size, type);
-    fill(img1_host, 0, 255);
+    cv::Mat img1(size, type);
+    fillRandom(img1);
 
-    cv::Mat img2_host(size, type);
-    fill(img2_host, 0, 255);
+    cv::Mat img2(size, type);
+    fillRandom(img2);
 
-    cv::gpu::GpuMat img1(img1_host);
-    cv::gpu::GpuMat img2(img2_host);
-    cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));
-    cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
-    cv::gpu::GpuMat 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(img1, img2, weights1, weights2, dst);
+    cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);
+        cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // Convolve
 
-IMPLEMENT_PARAM_CLASS(KSize, int)
-IMPLEMENT_PARAM_CLASS(Ccorr, bool)
+DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
 
-GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
+PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES, Values(17, 27, 32, 64), Bool()))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int templ_size = GET_PARAM(2);
-    bool ccorr = GET_PARAM(3);
+    declare.time(2.0);
 
-    cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);
-    image.setTo(cv::Scalar(1.0));
+    cv::Size size = GET_PARAM(0);
+    int templ_size = GET_PARAM(1);
+    bool ccorr = GET_PARAM(2);
 
-    cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
-    templ.setTo(cv::Scalar(1.0));
+    cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+    d_image.setTo(cv::Scalar(1.0));
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::ConvolveBuf buf;
+    cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+    d_templ.setTo(cv::Scalar(1.0));
 
-    cv::gpu::convolve(image, templ, dst, ccorr, buf);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::ConvolveBuf d_buf;
 
-    declare.time(2.0);
+    cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
 
     TEST_CYCLE()
     {
-        cv::gpu::convolve(image, templ, dst, ccorr, buf);
+        cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),
-    testing::Values(Ccorr(false), Ccorr(true))));
-
 ////////////////////////////////////////////////////////////////////////////////
-// MatchTemplate_8U
+// MatchTemplate8U
 
 CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)
-#define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))
+#define ALL_TEMPLATE_METHODS ValuesIn(TemplateMethod::all())
 
-IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)
+DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, int, TemplateMethod);
 
-GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)
+PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
+    Values(1, 3, 4),
+    ALL_TEMPLATE_METHODS))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    cv::Size templ_size = GET_PARAM(2);
-    int cn = GET_PARAM(3);
-    int method = GET_PARAM(4);
+    cv::Size size = GET_PARAM(0);
+    cv::Size templ_size = GET_PARAM(1);
+    int cn = GET_PARAM(2);
+    int method = GET_PARAM(3);
 
-    cv::Mat image_host(size, CV_MAKE_TYPE(CV_8U, cn));
-    fill(image_host, 0, 255);
+    cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));
+    fillRandom(image);
 
-    cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_8U, cn));
-    fill(templ_host, 0, 255);
+    cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
+    fillRandom(templ);
 
-    cv::gpu::GpuMat image(image_host);
-    cv::gpu::GpuMat templ(templ_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_image(image);
+    cv::gpu::GpuMat d_templ(templ);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::matchTemplate(image, templ, dst, method);
+    cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
 
     TEST_CYCLE()
     {
-        cv::gpu::matchTemplate(image, templ, dst, method);
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
     }
 };
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    ALL_TEMPLATE_METHODS));
-
 ////////////////////////////////////////////////////////////////////////////////
-// MatchTemplate_32F
+// MatchTemplate32F
 
-GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)
+PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
+    Values(1, 3, 4),
+    Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    cv::Size templ_size = GET_PARAM(2);
-    int cn = GET_PARAM(3);
-    int method = GET_PARAM(4);
+    cv::Size size = GET_PARAM(0);
+    cv::Size templ_size = GET_PARAM(1);
+    int cn = GET_PARAM(2);
+    int method = GET_PARAM(3);
 
-    cv::Mat image_host(size, CV_MAKE_TYPE(CV_32F, cn));
-    fill(image_host, 0, 255);
+    cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));
+    fillRandom(image);
 
-    cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_32F, cn));
-    fill(templ_host, 0, 255);
+    cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
+    fillRandom(templ);
 
-    cv::gpu::GpuMat image(image_host);
-    cv::gpu::GpuMat templ(templ_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_image(image);
+    cv::gpu::GpuMat d_templ(templ);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::matchTemplate(image, templ, dst, method);
+    cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
 
     TEST_CYCLE()
     {
-        cv::gpu::matchTemplate(image, templ, dst, method);
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
     }
 };
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));
-
 //////////////////////////////////////////////////////////////////////
 // MulSpectrums
 
 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
 
-GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
 
-    cv::Size size = GET_PARAM(1);
-    int flag = GET_PARAM(2);
+PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(0, DftFlags(cv::DFT_ROWS))))
+{
+    cv::Size size = GET_PARAM(0);
+    int flag = GET_PARAM(1);
 
-    cv::Mat a_host(size, CV_32FC2);
-    fill(a_host, 0, 100);
+    cv::Mat a(size, CV_32FC2);
+    fillRandom(a, 0, 100);
 
-    cv::Mat b_host(size, CV_32FC2);
-    fill(b_host, 0, 100);
+    cv::Mat b(size, CV_32FC2);
+    fillRandom(b, 0, 100);
 
-    cv::gpu::GpuMat a(a_host);
-    cv::gpu::GpuMat b(b_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_a(a);
+    cv::gpu::GpuMat d_b(b);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::mulSpectrums(a, b, dst, flag);
+    cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
 
     TEST_CYCLE()
     {
-        cv::gpu::mulSpectrums(a, b, dst, flag);
+        cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
-
 //////////////////////////////////////////////////////////////////////
 // MulAndScaleSpectrums
 
-GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
     float scale = 1.f / size.area();
 
-    cv::Mat src1_host(size, CV_32FC2);
-    fill(src1_host, 0, 100);
+    cv::Mat src1(size, CV_32FC2);
+    fillRandom(src1, 0, 100);
 
-    cv::Mat src2_host(size, CV_32FC2);
-    fill(src2_host, 0, 100);
+    cv::Mat src2(size, CV_32FC2);
+    fillRandom(src2, 0, 100);
 
-    cv::gpu::GpuMat src1(src1_host);
-    cv::gpu::GpuMat src2(src2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src1(src1);
+    cv::gpu::GpuMat d_src2(src2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);
+    cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
 
     TEST_CYCLE()
     {
-        cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);
+        cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Dft
 
-GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)
+PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int flag = GET_PARAM(2);
+    declare.time(2.0);
 
-    cv::Mat src_host(size, CV_32FC2);
-    fill(src_host, 0, 100);
+    cv::Size size = GET_PARAM(0);
+    int flag = GET_PARAM(1);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, CV_32FC2);
+    fillRandom(src, 0, 100);
 
-    cv::gpu::dft(src, dst, size, flag);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    declare.time(2.0);
+    cv::gpu::dft(d_src, d_dst, size, flag);
 
     TEST_CYCLE()
     {
-        cv::gpu::dft(src, dst, size, flag);
+        cv::gpu::dft(d_src, d_dst, size, flag);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));
-
 //////////////////////////////////////////////////////////////////////
 // CornerHarris
 
-IMPLEMENT_PARAM_CLASS(BlockSize, int)
-IMPLEMENT_PARAM_CLASS(ApertureSize, int)
+DEF_PARAM_TEST(Image_Type_Border_BlockSz_ApertureSz, string, MatType, BorderMode, int, int);
 
-GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)
+PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
+    Values<string>("gpu/stereobm/aloe-L.png"),
+    Values(CV_8UC1, CV_32FC1),
+    Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
+    Values(3, 5, 7),
+    Values(0, 3, 5, 7)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    double k = 0.5;
 
+    string fileName = GET_PARAM(0);
     int type = GET_PARAM(1);
-    int borderType = GET_PARAM(2);
+    int borderMode = GET_PARAM(2);
     int blockSize = GET_PARAM(3);
     int apertureSize = GET_PARAM(4);
 
-    cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
 
-    cv::gpu::GpuMat src(img);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat Dx;
-    cv::gpu::GpuMat Dy;
-    cv::gpu::GpuMat buf;
-
-    double k = 0.5;
+    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(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);
+    cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
 
     TEST_CYCLE()
     {
-        cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);
+        cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
-    testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),
-    testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));
-
 //////////////////////////////////////////////////////////////////////
 // CornerMinEigenVal
 
-GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)
+PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Combine(
+    Values<string>("gpu/stereobm/aloe-L.png"),
+    Values(CV_8UC1, CV_32FC1),
+    Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
+    Values(3, 5, 7),
+    Values(0, 3, 5, 7)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
+    string fileName = GET_PARAM(0);
     int type = GET_PARAM(1);
-    int borderType = GET_PARAM(2);
+    int borderMode = GET_PARAM(2);
     int blockSize = GET_PARAM(3);
     int apertureSize = GET_PARAM(4);
 
-    cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
 
-    cv::gpu::GpuMat src(img);
-    cv::gpu::GpuMat dst;
-    cv::gpu::GpuMat Dx;
-    cv::gpu::GpuMat Dy;
-    cv::gpu::GpuMat 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(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);
+    cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
 
     TEST_CYCLE()
     {
-        cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);
+        cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
-    testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),
-    testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));
-
 //////////////////////////////////////////////////////////////////////
 // BuildWarpPlaneMaps
 
-GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
     cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);
-    cv::gpu::GpuMat map_x;
-    cv::gpu::GpuMat map_y;
 
-    cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, 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, map_x, 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);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // BuildWarpCylindricalMaps
 
-GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
-    cv::gpu::GpuMat map_x;
-    cv::gpu::GpuMat map_y;
 
-    cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, 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, map_x, map_y);
+        cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // BuildWarpSphericalMaps
 
-GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
-    cv::gpu::GpuMat map_x;
-    cv::gpu::GpuMat map_y;
 
-    cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);
+    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);
 
     TEST_CYCLE()
     {
-        cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);
+        cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // Rotate
 
-GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Depth_Cn_Inter, cv::Size, MatDepth, int, Interpolation);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4),
+    Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
     int interpolation = GET_PARAM(3);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
+
+    cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
 
     TEST_CYCLE()
     {
-        cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);
+        cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))));
-
 //////////////////////////////////////////////////////////////////////
 // PyrDown
 
-GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::pyrDown(src, dst);
+    cv::gpu::pyrDown(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::pyrDown(src, dst);
+        cv::gpu::pyrDown(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // PyrUp
 
-GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::pyrUp(src, dst);
+    cv::gpu::pyrUp(d_src, d_dst);
 
     TEST_CYCLE()
     {
-        cv::gpu::pyrUp(src, dst);
+        cv::gpu::pyrUp(d_src, d_dst);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // CvtColor
 
-GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    CvtColorInfo info = GET_PARAM(3);
+DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);
 
-    cv::Mat src_host(size, CV_MAKETYPE(depth, info.scn));
-    fill(src_host, 0, 255);
+PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
+    GPU_TYPICAL_MAT_SIZES,
+    Values(CV_8U, CV_16U, CV_32F),
+    Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
+           CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
+           CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),
+           CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),
+           CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),
+           CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),
+           CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),
+           CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),
+           CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),
+           CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),
+           CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),
+           CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),
+           CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),
+           CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),
+           CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
+           CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
+           CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),
+           CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),
+           CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    CvtColorInfo info = GET_PARAM(2);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
+    fillRandom(src);
 
-    if (info.code >= cv::COLOR_BayerBG2BGR && info.code <= cv::COLOR_BayerGR2BGR)
-        info.dcn = 4;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::cvtColor(src, dst, info.code, info.dcn);
+    cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
 
     TEST_CYCLE()
     {
-        cv::gpu::cvtColor(src, dst, info.code, info.dcn);
+        cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
-    testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
-                    CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
-                    CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),
-                    CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),
-                    CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),
-                    CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),
-                    CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),
-                    CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),
-                    CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),
-                    CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),
-                    CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),
-                    CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),
-                    CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))));
-
 //////////////////////////////////////////////////////////////////////
 // SwapChannels
 
-GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size)
+PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
+    cv::Size size = GetParam();
 
-    cv::Mat src_host(size, CV_8UC4);
-    fill(src_host, 0, 255);
-
-    cv::gpu::GpuMat src(src_host);
+    cv::Mat src(size, CV_8UC4);
+    fillRandom(src);
 
     const int dstOrder[] = {2, 1, 0, 3};
 
-    cv::gpu::swapChannels(src, dstOrder);
+    cv::gpu::GpuMat d_src(src);
+
+    cv::gpu::swapChannels(d_src, dstOrder);
 
     TEST_CYCLE()
     {
-        cv::gpu::swapChannels(src, dstOrder);
+        cv::gpu::swapChannels(d_src, dstOrder);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES));
-
 //////////////////////////////////////////////////////////////////////
 // AlphaComp
 
 CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL)
+#define ALL_ALPHA_OPS ValuesIn(AlphaOp::all())
 
-GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, MatType, AlphaOp)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int alpha_op = GET_PARAM(3);
+PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4), ALL_ALPHA_OPS))
+{
+    cv::Size size = GET_PARAM(0);
+    int type = GET_PARAM(1);
+    int alpha_op = GET_PARAM(2);
 
-    cv::Mat img1_host(size, type);
-    fill(img1_host, 0, 255);
+    cv::Mat img1(size, type);
+    fillRandom(img1);
 
-    cv::Mat img2_host(size, type);
-    fill(img2_host, 0, 255);
+    cv::Mat img2(size, type);
+    fillRandom(img2);
 
-    cv::gpu::GpuMat img1(img1_host);
-    cv::gpu::GpuMat img2(img2_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_img1(img1);
+    cv::gpu::GpuMat d_img2(img2);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::alphaComp(img1, img2, dst, alpha_op);
+    cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
 
     TEST_CYCLE()
     {
-        cv::gpu::alphaComp(img1, img2, dst, alpha_op);
+        cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC4), MatType(CV_16UC4), MatType(CV_32SC4), MatType(CV_32FC4)),
-    testing::Values(AlphaOp(cv::gpu::ALPHA_OVER),
-                    AlphaOp(cv::gpu::ALPHA_IN),
-                    AlphaOp(cv::gpu::ALPHA_OUT),
-                    AlphaOp(cv::gpu::ALPHA_ATOP),
-                    AlphaOp(cv::gpu::ALPHA_XOR),
-                    AlphaOp(cv::gpu::ALPHA_PLUS),
-                    AlphaOp(cv::gpu::ALPHA_OVER_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_IN_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_OUT_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_ATOP_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_XOR_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_PLUS_PREMUL),
-                    AlphaOp(cv::gpu::ALPHA_PREMUL))));
-
 //////////////////////////////////////////////////////////////////////
-// ImagePyramid
+// ImagePyramidBuild
 
-GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat d_src(src);
 
-    cv::gpu::ImagePyramid pyr;
+    cv::gpu::ImagePyramid d_pyr;
 
-    pyr.build(src, 5);
+    d_pyr.build(d_src, 5);
 
     TEST_CYCLE()
     {
-        pyr.build(src, 5);
+        d_pyr.build(d_src, 5);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
+//////////////////////////////////////////////////////////////////////
+// ImagePyramidGetLayer
 
-GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
+
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Size dstSize(size.width / 2 + 10, size.height / 2 + 10);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    cv::gpu::ImagePyramid pyr(src, 3);
+    cv::gpu::ImagePyramid d_pyr(d_src, 3);
 
-    pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));
+    d_pyr.getLayer(d_dst, dstSize);
 
     TEST_CYCLE()
     {
-        pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));
+        d_pyr.getLayer(d_dst, dstSize);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // HoughLines
 
-IMPLEMENT_PARAM_CLASS(DoSort, bool)
+DEF_PARAM_TEST(Sz_DoSort, cv::Size, bool);
 
-GPU_PERF_TEST(HoughLines, cv::gpu::DeviceInfo, cv::Size, DoSort)
+PERF_TEST_P(Sz_DoSort, ImgProc_HoughLines, Combine(GPU_TYPICAL_MAT_SIZES, Bool()))
 {
     declare.time(30.0);
 
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const bool doSort = GET_PARAM(2);
+    const cv::Size size = GET_PARAM(0);
+    const bool doSort = GET_PARAM(1);
 
     const float rho = 1.0f;
     const float theta = CV_PI / 180.0f;
@@ -1365,6 +1201,7 @@ GPU_PERF_TEST(HoughLines, cv::gpu::DeviceInfo, cv::Size, DoSort)
     cv::gpu::GpuMat d_lines;
     cv::gpu::GpuMat d_accum;
     cv::gpu::GpuMat d_buf;
+
     cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);
 
     TEST_CYCLE()
@@ -1373,9 +1210,4 @@ GPU_PERF_TEST(HoughLines, cv::gpu::DeviceInfo, cv::Size, DoSort)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ImgProc, HoughLines, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DoSort(false), DoSort(true))));
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_labeling.cpp b/modules/gpu/perf/perf_labeling.cpp
index 2c537ebbeb..86d67ff93b 100644
--- a/modules/gpu/perf/perf_labeling.cpp
+++ b/modules/gpu/perf/perf_labeling.cpp
@@ -41,14 +41,16 @@
 
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
 
-GPU_PERF_TEST(ConnectedComponents, cv::gpu::DeviceInfo, cv::Size)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+namespace {
+
+DEF_PARAM_TEST_1(Image, string);
 
-    cv::Mat image = readImage("gpu/labeling/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/aloe-disp.png"))
+{
+    cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
 
     // cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
 
@@ -70,6 +72,4 @@ GPU_PERF_TEST(ConnectedComponents, cv::gpu::DeviceInfo, cv::Size)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Labeling, ConnectedComponents, testing::Combine(ALL_DEVICES, testing::Values(cv::Size(261, 262))));
-
-#endif
\ No newline at end of file
+} // namespace
diff --git a/modules/gpu/perf/perf_main.cpp b/modules/gpu/perf/perf_main.cpp
index 0cd4002775..988c95ae0e 100644
--- a/modules/gpu/perf/perf_main.cpp
+++ b/modules/gpu/perf/perf_main.cpp
@@ -2,11 +2,98 @@
 
 #ifdef HAVE_CUDA
 
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+using namespace cvtest;
+using namespace testing;
+
+void printInfo()
+{
+#if defined _WIN32
+#   if defined _WIN64
+        puts("OS: Windows x64");
+#   else
+        puts("OS: Windows x32");
+#   endif
+#elif defined linux
+#   if defined _LP64
+        puts("OS: Linux x64");
+#   else
+        puts("OS: Linux x32");
+#   endif
+#elif defined __APPLE__
+#   if defined _LP64
+        puts("OS: Apple x64");
+#   else
+        puts("OS: Apple x32");
+#   endif
+#endif
+
+    int driver;
+    cudaDriverGetVersion(&driver);
+
+    printf("CUDA Driver  version: %d\n", driver);
+    printf("CUDA Runtime version: %d\n", CUDART_VERSION);
+
+    puts("GPU module was compiled for the following GPU archs:");
+    printf("    BIN: %s\n", CUDA_ARCH_BIN);
+    printf("    PTX: %s\n\n", CUDA_ARCH_PTX);
+
+    int deviceCount = getCudaEnabledDeviceCount();
+    printf("CUDA device count: %d\n\n", deviceCount);
+
+    for (int i = 0; i < deviceCount; ++i)
+    {
+        DeviceInfo info(i);
+
+        printf("Device %d:\n", i);
+        printf("    Name: %s\n", info.name().c_str());
+        printf("    Compute capability version: %d.%d\n", info.majorVersion(), info.minorVersion());
+        printf("    Multi Processor Count: %d\n", info.multiProcessorCount());
+        printf("    Total memory: %d Mb\n", static_cast<int>(static_cast<int>(info.totalMemory() / 1024.0) / 1024.0));
+        printf("    Free  memory: %d Mb\n", static_cast<int>(static_cast<int>(info.freeMemory() / 1024.0) / 1024.0));
+        if (!info.isCompatible())
+            puts("    !!! This device is NOT compatible with current GPU module build\n");
+        printf("\n");
+    }
+}
+
 int main(int argc, char **argv)
 {
+    CommandLineParser parser(argc, (const char**)argv,
+                             "{ print_info_only | print_info_only | false | Print information about system and exit }"
+                             "{ device | device | 0 | Device on which tests will be executed }");
+
+    printInfo();
+
+    if (parser.get<bool>("print_info_only"))
+        return 0;
+
+    int device = parser.get<int>("device");
+
+    if (device < 0 || device >= getCudaEnabledDeviceCount())
+    {
+        cerr << "Incorrect device number - " << device << endl;
+        return -1;
+    }
+
+    DeviceInfo info(device);
+    if (!info.isCompatible())
+    {
+        cerr << "Device " << device << " [" << info.name() << "] is NOT compatible with current GPU module build" << endl;
+        return -1;
+    }
+
+    std::cout << "Run tests on device " << device << '\n' << std::endl;
+
+    setDevice(device);
+
     testing::InitGoogleTest(&argc, argv);
     perf::TestBase::Init(argc, argv);
     return RUN_ALL_TESTS();
+
+    return 0;
 }
 
 #else
diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp
index 5cc24402c0..c014b19da8 100644
--- a/modules/gpu/perf/perf_matop.cpp
+++ b/modules/gpu/perf/perf_matop.cpp
@@ -1,141 +1,115 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // SetTo
 
-GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F, CV_64F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::gpu::GpuMat src(size, type);
     cv::Scalar val(1, 2, 3, 4);
 
-    src.setTo(val);
+    cv::gpu::GpuMat d_src(size, type);
+
+    d_src.setTo(val);
 
     TEST_CYCLE()
     {
-        src.setTo(val);
+        d_src.setTo(val);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // SetToMasked
 
-GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F, CV_64F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat mask_host(size, CV_8UC1);
-    fill(mask_host, 0, 2);
+    cv::Mat mask(size, CV_8UC1);
+    fillRandom(mask, 0, 2);
 
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar val(1, 2, 3, 4);
-    cv::gpu::GpuMat mask(mask_host);
 
-    src.setTo(val, mask);
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_mask(mask);
+
+    d_src.setTo(val, d_mask);
 
     TEST_CYCLE()
     {
-        src.setTo(val, mask);
+        d_src.setTo(val, d_mask);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // CopyToMasked
 
-GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)
+PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F, CV_64F), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Size size = GET_PARAM(0);
+    int depth = GET_PARAM(1);
+    int channels = GET_PARAM(2);
 
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    int type = CV_MAKE_TYPE(depth, channels);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src);
 
-    cv::Mat mask_host(size, CV_8UC1);
-    fill(mask_host, 0, 2);
+    cv::Mat mask(size, CV_8UC1);
+    fillRandom(mask, 0, 2);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat mask(mask_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_mask(mask);
+    cv::gpu::GpuMat d_dst;
 
-    src.copyTo(dst, mask);
+    d_src.copyTo(d_dst, d_mask);
 
     TEST_CYCLE()
     {
-        src.copyTo(dst, mask);
+        d_src.copyTo(d_dst, d_mask);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
 //////////////////////////////////////////////////////////////////////
 // ConvertTo
 
-GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Sz_2Depth, cv::Size, MatDepth, MatDepth);
 
-    cv::Size size = GET_PARAM(1);
-    int depth1 = GET_PARAM(2);
-    int depth2 = GET_PARAM(3);
+PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16U, CV_32F, CV_64F), Values(CV_8U, CV_16U, CV_32F, CV_64F)))
+{
+    cv::Size size = GET_PARAM(0);
+    int depth1 = GET_PARAM(1);
+    int depth2 = GET_PARAM(2);
 
-    cv::Mat src_host(size, depth1);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, depth1);
+    fillRandom(src);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat d_src(src);
+    cv::gpu::GpuMat d_dst;
 
-    src.convertTo(dst, depth2, 0.5, 1.0);
+    d_src.convertTo(d_dst, depth2, 0.5, 1.0);
 
     TEST_CYCLE()
     {
-        src.convertTo(dst, depth2, 0.5, 1.0);
+        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F))));
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index c376586c9b..9c1f7919f9 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -1,85 +1,84 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 ///////////////////////////////////////////////////////////////
 // HOG
 
-GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST_1(Image, string);
 
-    cv::Mat img_host = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
+{
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::GpuMat img(img_host);
     std::vector<cv::Rect> found_locations;
 
-    cv::gpu::HOGDescriptor hog;
-    hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+    cv::gpu::GpuMat d_img(img);
 
-    hog.detectMultiScale(img, found_locations);
+    cv::gpu::HOGDescriptor d_hog;
+    d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
+    d_hog.detectMultiScale(d_img, found_locations);
 
     TEST_CYCLE()
     {
-        hog.detectMultiScale(img, found_locations);
+        d_hog.detectMultiScale(d_img, found_locations);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ObjDetect, HOG, ALL_DEVICES);
-
 ///////////////////////////////////////////////////////////////
 // HaarClassifier
 
-GPU_PERF_TEST_1(HaarClassifier, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+typedef pair<string, string> pair_string;
+DEF_PARAM_TEST_1(ImageAndCascade, pair_string);
 
-    cv::Mat img_host = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
+    Values<pair_string>(make_pair("gpu/haarcascade/group_1_640x480_VGA.pgm", "gpu/perf/haarcascade_frontalface_alt.xml")))
+{
+    cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::CascadeClassifier_GPU cascade;
+    cv::gpu::CascadeClassifier_GPU d_cascade;
 
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));
+    ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat objects_buffer;
+    cv::gpu::GpuMat d_img(img);
+    cv::gpu::GpuMat d_objects_buffer;
 
-    cascade.detectMultiScale(img, objects_buffer);
+    d_cascade.detectMultiScale(d_img, d_objects_buffer);
 
     TEST_CYCLE()
     {
-        cascade.detectMultiScale(img, objects_buffer);
+        d_cascade.detectMultiScale(d_img, d_objects_buffer);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ObjDetect, HaarClassifier, ALL_DEVICES);
+///////////////////////////////////////////////////////////////
+// LBP cascade
 
-//===================== LBP cascade ==========================//
-GPU_PERF_TEST_1(LBPClassifier, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
+    Values<pair_string>(make_pair("gpu/haarcascade/group_1_640x480_VGA.pgm", "gpu/lbpcascade/lbpcascade_frontalface.xml")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    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 img(img_host);
-        cv::gpu::GpuMat gpu_rects;
-    cv::gpu::CascadeClassifier_GPU cascade;
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/lbpcascade/lbpcascade_frontalface.xml")));
+    d_cascade.detectMultiScale(d_img, d_gpu_rects);
 
-    cascade.detectMultiScale(img, gpu_rects);
     TEST_CYCLE()
     {
-        cascade.detectMultiScale(img, gpu_rects);
+        d_cascade.detectMultiScale(d_img, d_gpu_rects);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(ObjDetect, LBPClassifier, ALL_DEVICES);
-
-#endif
+} // namespace
diff --git a/modules/gpu/perf/perf_precomp.hpp b/modules/gpu/perf/perf_precomp.hpp
index 19608bde10..be3f234a35 100644
--- a/modules/gpu/perf/perf_precomp.hpp
+++ b/modules/gpu/perf/perf_precomp.hpp
@@ -11,6 +11,10 @@
 
 #include "cvconfig.h"
 
+#ifdef HAVE_CUDA
+#include <cuda_runtime.h>
+#endif
+
 #include "opencv2/ts/ts.hpp"
 #include "opencv2/ts/ts_perf.hpp"
 
@@ -18,6 +22,10 @@
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/gpu/gpu.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/video/video.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include "opencv2/legacy/legacy.hpp"
 
 #include "perf_utility.hpp"
 
diff --git a/modules/gpu/perf/perf_utility.cpp b/modules/gpu/perf/perf_utility.cpp
index bf6bdfe739..42862f49d1 100644
--- a/modules/gpu/perf/perf_utility.cpp
+++ b/modules/gpu/perf/perf_utility.cpp
@@ -4,12 +4,17 @@ using namespace std;
 using namespace cv;
 using namespace cv::gpu;
 
-void fill(Mat& m, double a, double b)
+void fillRandom(Mat& m, double a, double b)
 {
     RNG rng(123456789);
     rng.fill(m, RNG::UNIFORM, Scalar::all(a), Scalar::all(b));
 }
 
+Mat readImage(const string& fileName, int flags)
+{
+    return imread(perf::TestBase::getDataPath(fileName), flags);
+}
+
 void PrintTo(const CvtColorInfo& info, ostream* os)
 {
     static const char* str[] =
@@ -184,37 +189,3 @@ void PrintTo(const CvtColorInfo& info, ostream* os)
 
     *os << str[info.code];
 }
-
-void cv::gpu::PrintTo(const DeviceInfo& info, ostream* os)
-{
-    *os << info.name();
-}
-
-Mat readImage(const string& fileName, int flags)
-{
-    return imread(perf::TestBase::getDataPath(fileName), flags);
-}
-
-const vector<DeviceInfo>& devices()
-{
-    static vector<DeviceInfo> devs;
-    static bool first = true;
-
-    if (first)
-    {
-        int deviceCount = getCudaEnabledDeviceCount();
-
-        devs.reserve(deviceCount);
-
-        for (int i = 0; i < deviceCount; ++i)
-        {
-            DeviceInfo info(i);
-            if (info.isCompatible())
-                devs.push_back(info);
-        }
-
-        first = false;
-    }
-
-    return devs;
-}
diff --git a/modules/gpu/perf/perf_utility.hpp b/modules/gpu/perf/perf_utility.hpp
index 8693cfc3c0..b717030ff3 100644
--- a/modules/gpu/perf/perf_utility.hpp
+++ b/modules/gpu/perf/perf_utility.hpp
@@ -1,13 +1,21 @@
 #ifndef __OPENCV_PERF_GPU_UTILITY_HPP__
 #define __OPENCV_PERF_GPU_UTILITY_HPP__
 
-void fill(cv::Mat& m, double a, double b);
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/gpumat.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/ts/ts_perf.hpp"
+
+void fillRandom(cv::Mat& m, double a = 0.0, double b = 255.0);
+cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
 
 using perf::MatType;
 using perf::MatDepth;
 
 CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)
-        CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA)
+#define ALL_BORDER_MODES testing::ValuesIn(BorderMode::all())
+CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA)
+#define ALL_INTERPOLATIONS testing::ValuesIn(Interpolation::all())
 CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_HAMMING)
 
 struct CvtColorInfo
@@ -18,60 +26,18 @@ struct CvtColorInfo
 
     explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}
 };
-
 void PrintTo(const CvtColorInfo& info, std::ostream* os);
 
-#define IMPLEMENT_PARAM_CLASS(name, type) \
-    class name \
-    { \
-    public: \
-        name ( type arg = type ()) : val_(arg) {} \
-        operator type () const {return val_;} \
-    private: \
-        type val_; \
-    }; \
-    inline void PrintTo( name param, std::ostream* os) \
-    { \
-        *os << #name <<  " = " << testing::PrintToString(static_cast< type >(param)); \
-    }
-
-IMPLEMENT_PARAM_CLASS(Channels, int)
-
-namespace cv { namespace gpu
-{
-    void PrintTo(const cv::gpu::DeviceInfo& info, std::ostream* os);
-}}
-
-#define GPU_PERF_TEST(name, ...) \
-    struct name : perf::TestBaseWithParam< std::tr1::tuple< __VA_ARGS__ > > \
-    { \
-    public: \
-        name() {} \
-    protected: \
-        void PerfTestBody(); \
-    }; \
-    TEST_P(name, perf){ RunPerfTestBody(); } \
-    void name :: PerfTestBody()
-
-#define GPU_PERF_TEST_1(name, param_type) \
-    struct name : perf::TestBaseWithParam< param_type > \
-    { \
-    public: \
-        name() {} \
-    protected: \
-        void PerfTestBody(); \
-    }; \
-    TEST_P(name, perf){ RunPerfTestBody(); } \
-    void name :: PerfTestBody()
-
-#define GPU_TYPICAL_MAT_SIZES testing::Values(perf::szSXGA, perf::sz1080p, cv::Size(1800, 1500))
-
-cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
+#define GET_PARAM(k) std::tr1::get< k >(GetParam())
 
-const std::vector<cv::gpu::DeviceInfo>& devices();
+#define DEF_PARAM_TEST(name, ...) typedef ::perf::TestBaseWithParam< std::tr1::tuple< __VA_ARGS__ > > name
+#define DEF_PARAM_TEST_1(name, param_type) typedef ::perf::TestBaseWithParam< param_type > name
 
-#define ALL_DEVICES testing::ValuesIn(devices())
+DEF_PARAM_TEST_1(Sz, cv::Size);
+typedef perf::Size_MatType Sz_Type;
+DEF_PARAM_TEST(Sz_Depth, cv::Size, MatDepth);
+DEF_PARAM_TEST(Sz_Depth_Cn, cv::Size, MatDepth, int);
 
-#define GET_PARAM(k) std::tr1::get< k >(GetParam())
+#define GPU_TYPICAL_MAT_SIZES testing::Values(perf::szSXGA, perf::sz720p, perf::sz1080p)
 
 #endif // __OPENCV_PERF_GPU_UTILITY_HPP__
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 6e577a4a40..a5a1e4da57 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -1,305 +1,277 @@
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////
 // BroxOpticalFlow
 
-GPU_PERF_TEST_1(BroxOpticalFlow, cv::gpu::DeviceInfo)
+typedef pair<string, string> pair_string;
+
+DEF_PARAM_TEST_1(ImagePair, pair_string);
+
+PERF_TEST_P(ImagePair, Video_BroxOpticalFlow, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(10);
 
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0_host.empty());
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1_host.empty());
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
+    frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
+    frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat 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*/);
 
-    d_flow(frame0, frame1, u, v);
-
-    declare.time(10);
+    d_flow(d_frame0, d_frame1, d_u, d_v);
 
     TEST_CYCLE()
     {
-        d_flow(frame0, frame1, u, v);
+        d_flow(d_frame0, d_frame1, d_u, d_v);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, BroxOpticalFlow, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // InterpolateFrames
 
-GPU_PERF_TEST_1(InterpolateFrames, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Video_InterpolateFrames, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0_host.empty());
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-    cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1_host.empty());
+    frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
+    frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat fu, fv;
-    cv::gpu::GpuMat bu, 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*/);
 
-    d_flow(frame0, frame1, fu, fv);
-    d_flow(frame1, frame0, bu, bv);
+    d_flow(d_frame0, d_frame1, d_fu, d_fv);
+    d_flow(d_frame1, d_frame0, d_bu, d_bv);
 
-    cv::gpu::GpuMat newFrame;
-    cv::gpu::GpuMat buf;
+    cv::gpu::GpuMat d_newFrame;
+    cv::gpu::GpuMat d_buf;
 
-    cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, 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(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);
+        cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, InterpolateFrames, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // CreateOpticalFlowNeedleMap
 
-GPU_PERF_TEST_1(CreateOpticalFlowNeedleMap, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0_host.empty());
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1_host.empty());
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
+    frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
+    frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u, 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*/);
 
-    d_flow(frame0, frame1, u, v);
+    d_flow(d_frame0, d_frame1, d_u, d_v);
 
-    cv::gpu::GpuMat vertex, colors;
+    cv::gpu::GpuMat d_vertex, d_colors;
 
-    cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);
+    cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
 
     TEST_CYCLE()
     {
-        cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);
+        cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, CreateOpticalFlowNeedleMap, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // GoodFeaturesToTrack
 
-IMPLEMENT_PARAM_CLASS(MinDistance, double)
+DEF_PARAM_TEST(Image_MinDistance, string, double);
 
-GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
+PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack, Combine(Values<string>("gpu/perf/aloe.jpg"), Values(0.0, 3.0)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
+    string fileName = GET_PARAM(0);
     double minDistance = GET_PARAM(1);
 
-    cv::Mat image_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image_host.empty());
+    cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
 
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(8000, 0.01, minDistance);
+    cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
 
-    cv::gpu::GpuMat image(image_host);
-    cv::gpu::GpuMat pts;
+    cv::gpu::GpuMat d_image(image);
+    cv::gpu::GpuMat d_pts;
 
-    detector(image, pts);
+    d_detector(d_image, d_pts);
 
     TEST_CYCLE()
     {
-        detector(image, pts);
+        d_detector(d_image, d_pts);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MinDistance(0.0), MinDistance(3.0))));
-
 //////////////////////////////////////////////////////
 // PyrLKOpticalFlowSparse
 
-IMPLEMENT_PARAM_CLASS(GraySource, bool)
-IMPLEMENT_PARAM_CLASS(Points, int)
-IMPLEMENT_PARAM_CLASS(WinSize, int)
-IMPLEMENT_PARAM_CLASS(Levels, int)
-IMPLEMENT_PARAM_CLASS(Iters, int)
+DEF_PARAM_TEST(ImagePair_Gray_NPts_WinSz_Levels_Iters, pair_string, bool, int, int, int, int);
 
-GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, GraySource, Points, WinSize, Levels, Iters)
+PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse, Combine(
+    Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")),
+    Bool(),
+    Values(1000, 2000, 4000, 8000),
+    Values(9, 13, 17, 21),
+    Values(1, 2, 3),
+    Values(1, 10, 30)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
+    pair_string imagePair = GET_PARAM(0);
     bool useGray = GET_PARAM(1);
     int points = GET_PARAM(2);
     int winSize = GET_PARAM(3);
     int levels = GET_PARAM(4);
     int iters = GET_PARAM(5);
 
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame0_host.empty());
+    cv::Mat frame0 = readImage(imagePair.first, useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame1_host.empty());
+    cv::Mat frame1 = readImage(imagePair.second, useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame1.empty());
 
     cv::Mat gray_frame;
     if (useGray)
-        gray_frame = frame0_host;
+        gray_frame = frame0;
     else
-        cv::cvtColor(frame0_host, gray_frame, cv::COLOR_BGR2GRAY);
+        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat pts;
+    cv::gpu::GpuMat d_pts;
 
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(points, 0.01, 0.0);
-    detector(cv::gpu::GpuMat(gray_frame), pts);
+    cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(points, 0.01, 0.0);
+    d_detector(cv::gpu::GpuMat(gray_frame), d_pts);
 
-    cv::gpu::PyrLKOpticalFlow pyrLK;
-    pyrLK.winSize = cv::Size(winSize, winSize);
-    pyrLK.maxLevel = levels - 1;
-    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 frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat nextPts;
-    cv::gpu::GpuMat status;
+    cv::gpu::GpuMat d_frame0(frame0);
+    cv::gpu::GpuMat d_frame1(frame1);
+    cv::gpu::GpuMat d_nextPts;
+    cv::gpu::GpuMat d_status;
 
-    pyrLK.sparse(frame0, frame1, pts, nextPts, status);
+    d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
 
     TEST_CYCLE()
     {
-        pyrLK.sparse(frame0, frame1, pts, nextPts, status);
+        d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(GraySource(true), GraySource(false)),
-    testing::Values(Points(1000), Points(2000), Points(4000), Points(8000)),
-    testing::Values(WinSize(9), WinSize(13), WinSize(17), WinSize(21)),
-    testing::Values(Levels(1), Levels(2), Levels(3)),
-    testing::Values(Iters(1), Iters(10), Iters(30))));
-
 //////////////////////////////////////////////////////
 // PyrLKOpticalFlowDense
 
-GPU_PERF_TEST(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo, WinSize, Levels, Iters)
+DEF_PARAM_TEST(ImagePair_WinSz_Levels_Iters, pair_string, int, int, int);
+
+PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
+    Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")),
+    Values(3, 5, 7, 9, 13, 17, 21),
+    Values(1, 2, 3),
+    Values(1, 10)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(30);
 
+    pair_string imagePair = GET_PARAM(0);
     int winSize = GET_PARAM(1);
     int levels = GET_PARAM(2);
     int iters = GET_PARAM(3);
 
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0_host.empty());
+    cv::Mat frame0 = readImage(imagePair.first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1_host.empty());
+    cv::Mat frame1 = readImage(imagePair.second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat 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 pyrLK;
+    cv::gpu::PyrLKOpticalFlow d_pyrLK;
+    d_pyrLK.winSize = cv::Size(winSize, winSize);
+    d_pyrLK.maxLevel = levels - 1;
+    d_pyrLK.iters = iters;
 
-    pyrLK.winSize = cv::Size(winSize, winSize);
-    pyrLK.maxLevel = levels - 1;
-    pyrLK.iters = iters;
-
-    pyrLK.dense(frame0, frame1, u, v);
-
-    declare.time(30);
+    d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
 
     TEST_CYCLE()
     {
-        pyrLK.dense(frame0, frame1, u, v);
+        d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowDense, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(WinSize(3), WinSize(5), WinSize(7), WinSize(9), WinSize(13), WinSize(17), WinSize(21)),
-    testing::Values(Levels(1), Levels(2), Levels(3)),
-    testing::Values(Iters(1), Iters(10))));
-
 //////////////////////////////////////////////////////
-// FarnebackOpticalFlowTest
+// FarnebackOpticalFlow
 
-GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow, Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0_host.empty());
+    declare.time(10);
 
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1_host.empty());
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-    cv::gpu::FarnebackOpticalFlow farneback;
+    cv::gpu::GpuMat d_frame0(frame0);
+    cv::gpu::GpuMat d_frame1(frame1);
+    cv::gpu::GpuMat d_u;
+    cv::gpu::GpuMat d_v;
 
-    farneback(frame0, frame1, u, v);
+    cv::gpu::FarnebackOpticalFlow d_farneback;
 
-    declare.time(10);
+    d_farneback(d_frame0, d_frame1, d_u, d_v);
 
     TEST_CYCLE()
     {
-        farneback(frame0, frame1, u, v);
+        d_farneback(d_frame0, d_frame1, d_u, d_v);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, FarnebackOpticalFlowTest, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // FGDStatModel
 
-GPU_PERF_TEST(FGDStatModel, cv::gpu::DeviceInfo, std::string)
+DEF_PARAM_TEST_1(Video, string);
+
+PERF_TEST_P(Video, Video_FGDStatModel, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(10);
 
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
+    string inputFile = perf::TestBase::getDataPath(GetParam());
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -312,8 +284,6 @@ GPU_PERF_TEST(FGDStatModel, cv::gpu::DeviceInfo, std::string)
     cv::gpu::FGDStatModel d_model(4);
     d_model.create(d_frame);
 
-    declare.time(10);
-
     for (int i = 0; i < 10; ++i)
     {
         cap >> frame;
@@ -327,23 +297,16 @@ GPU_PERF_TEST(FGDStatModel, cv::gpu::DeviceInfo, std::string)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, FGDStatModel, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
 //////////////////////////////////////////////////////
 // MOG
 
-IMPLEMENT_PARAM_CLASS(LearningRate, double)
+DEF_PARAM_TEST(Video_Cn_LearningRate, string, int, double);
 
-GPU_PERF_TEST(MOG, cv::gpu::DeviceInfo, std::string, Channels, LearningRate)
+PERF_TEST_P(Video_Cn_LearningRate, Video_MOG, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4), Values(0.0, 0.01)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-    double learningRate = GET_PARAM(3);
+    string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
+    int cn = GET_PARAM(1);
+    double learningRate = GET_PARAM(2);
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -351,8 +314,8 @@ GPU_PERF_TEST(MOG, cv::gpu::DeviceInfo, std::string, Channels, LearningRate)
     cv::Mat frame;
 
     cv::gpu::GpuMat d_frame;
-    cv::gpu::MOG_GPU mog;
-    cv::gpu::GpuMat foreground;
+    cv::gpu::MOG_GPU d_mog;
+    cv::gpu::GpuMat d_foreground;
 
     cap >> frame;
     ASSERT_FALSE(frame.empty());
@@ -369,7 +332,7 @@ GPU_PERF_TEST(MOG, cv::gpu::DeviceInfo, std::string, Channels, LearningRate)
 
     d_frame.upload(frame);
 
-    mog(d_frame, foreground, learningRate);
+    d_mog(d_frame, d_foreground, learningRate);
 
     for (int i = 0; i < 10; ++i)
     {
@@ -389,27 +352,20 @@ GPU_PERF_TEST(MOG, cv::gpu::DeviceInfo, std::string, Channels, LearningRate)
         d_frame.upload(frame);
 
         startTimer(); next();
-        mog(d_frame, foreground, learningRate);
+        d_mog(d_frame, d_foreground, learningRate);
         stopTimer();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, MOG, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    testing::Values(LearningRate(0.0), LearningRate(0.01))));
-
 //////////////////////////////////////////////////////
 // MOG2
 
-GPU_PERF_TEST(MOG2_update, cv::gpu::DeviceInfo, std::string, Channels)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST(Video_Cn, string, int);
 
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
+PERF_TEST_P(Video_Cn, Video_MOG2, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))
+{
+    string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
+    int cn = GET_PARAM(1);
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -417,8 +373,8 @@ GPU_PERF_TEST(MOG2_update, cv::gpu::DeviceInfo, std::string, Channels)
     cv::Mat frame;
 
     cv::gpu::GpuMat d_frame;
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground;
+    cv::gpu::MOG2_GPU d_mog2;
+    cv::gpu::GpuMat d_foreground;
 
     cap >> frame;
     ASSERT_FALSE(frame.empty());
@@ -435,7 +391,7 @@ GPU_PERF_TEST(MOG2_update, cv::gpu::DeviceInfo, std::string, Channels)
 
     d_frame.upload(frame);
 
-    mog2(d_frame, foreground);
+    d_mog2(d_frame, d_foreground);
 
     for (int i = 0; i < 10; ++i)
     {
@@ -455,23 +411,18 @@ GPU_PERF_TEST(MOG2_update, cv::gpu::DeviceInfo, std::string, Channels)
         d_frame.upload(frame);
 
         startTimer(); next();
-        mog2(d_frame, foreground);
+        d_mog2(d_frame, d_foreground);
         stopTimer();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, MOG2_update, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4))));
+//////////////////////////////////////////////////////
+// MOG2GetBackgroundImage
 
-GPU_PERF_TEST(MOG2_getBackgroundImage, cv::gpu::DeviceInfo, std::string, Channels)
+PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
+    string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
+    int cn = GET_PARAM(1);
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -479,8 +430,8 @@ GPU_PERF_TEST(MOG2_getBackgroundImage, cv::gpu::DeviceInfo, std::string, Channel
     cv::Mat frame;
 
     cv::gpu::GpuMat d_frame;
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground;
+    cv::gpu::MOG2_GPU d_mog2;
+    cv::gpu::GpuMat d_foreground;
 
     for (int i = 0; i < 10; ++i)
     {
@@ -499,33 +450,25 @@ GPU_PERF_TEST(MOG2_getBackgroundImage, cv::gpu::DeviceInfo, std::string, Channel
 
         d_frame.upload(frame);
 
-        mog2(d_frame, foreground);
+        d_mog2(d_frame, d_foreground);
     }
 
-    cv::gpu::GpuMat background;
-    mog2.getBackgroundImage(background);
+    cv::gpu::GpuMat d_background;
+    d_mog2.getBackgroundImage(d_background);
 
     TEST_CYCLE()
     {
-        mog2.getBackgroundImage(background);
+        d_mog2.getBackgroundImage(d_background);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, MOG2_getBackgroundImage, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4))));
-
 //////////////////////////////////////////////////////
 // VIBE
 
-GPU_PERF_TEST(VIBE, cv::gpu::DeviceInfo, std::string, Channels)
+PERF_TEST_P(Video_Cn, Video_VIBE, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
+    string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
+    int cn = GET_PARAM(1);
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -545,10 +488,10 @@ GPU_PERF_TEST(VIBE, cv::gpu::DeviceInfo, std::string, Channels)
     }
 
     cv::gpu::GpuMat d_frame(frame);
-    cv::gpu::VIBE_GPU vibe;
-    cv::gpu::GpuMat foreground;
+    cv::gpu::VIBE_GPU d_vibe;
+    cv::gpu::GpuMat d_foreground;
 
-    vibe(d_frame, foreground);
+    d_vibe(d_frame, d_foreground);
 
     for (int i = 0; i < 10; ++i)
     {
@@ -568,28 +511,21 @@ GPU_PERF_TEST(VIBE, cv::gpu::DeviceInfo, std::string, Channels)
         d_frame.upload(frame);
 
         startTimer(); next();
-        vibe(d_frame, foreground);
+        d_vibe(d_frame, d_foreground);
         stopTimer();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, VIBE, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4))));
-
 //////////////////////////////////////////////////////
 // GMG
 
-IMPLEMENT_PARAM_CLASS(MaxFeatures, int)
+DEF_PARAM_TEST(Video_Cn_MaxFeatures, string, int, int);
 
-GPU_PERF_TEST(GMG, cv::gpu::DeviceInfo, std::string, Channels, MaxFeatures)
+PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG, Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"), Values(1, 3, 4), Values(20, 40, 60)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-    int maxFeatures = GET_PARAM(3);
+    std::string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
+    int cn = GET_PARAM(1);
+    int maxFeatures = GET_PARAM(2);
 
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
@@ -611,10 +547,10 @@ GPU_PERF_TEST(GMG, cv::gpu::DeviceInfo, std::string, Channels, MaxFeatures)
     cv::gpu::GpuMat d_frame(frame);
     cv::gpu::GpuMat d_fgmask;
 
-    cv::gpu::GMG_GPU gmg;
-    gmg.maxFeatures = maxFeatures;
+    cv::gpu::GMG_GPU d_gmg;
+    d_gmg.maxFeatures = maxFeatures;
 
-    gmg(d_frame, d_fgmask);
+    d_gmg(d_frame, d_fgmask);
 
     for (int i = 0; i < 150; ++i)
     {
@@ -638,31 +574,20 @@ GPU_PERF_TEST(GMG, cv::gpu::DeviceInfo, std::string, Channels, MaxFeatures)
         d_frame.upload(frame);
 
         startTimer(); next();
-        gmg(d_frame, d_fgmask);
+        d_gmg(d_frame, d_fgmask);
         stopTimer();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, GMG, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    testing::Values(MaxFeatures(20), MaxFeatures(40), MaxFeatures(60))));
-
 //////////////////////////////////////////////////////
 // VideoWriter
 
-#ifdef WIN32
-
-GPU_PERF_TEST(VideoWriter, cv::gpu::DeviceInfo, std::string)
+PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
-    const double FPS = 25.0;
-
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    string inputFile = perf::TestBase::getDataPath(GetParam());
+    string outputFile = cv::tempfile(".avi");
 
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    std::string outputFile = cv::tempfile(".avi");
+    const double FPS = 25.0;
 
     cv::VideoCapture reader(inputFile);
     ASSERT_TRUE( reader.isOpened() );
@@ -690,39 +615,26 @@ GPU_PERF_TEST(VideoWriter, cv::gpu::DeviceInfo, std::string)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, VideoWriter, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-#endif // WIN32
-
 //////////////////////////////////////////////////////
 // VideoReader
 
-GPU_PERF_TEST(VideoReader, cv::gpu::DeviceInfo, std::string)
+PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
+    declare.time(20);
 
-    cv::gpu::VideoReader_GPU reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
+    string inputFile = perf::TestBase::getDataPath(GetParam());
 
-    cv::gpu::GpuMat frame;
+    cv::gpu::VideoReader_GPU d_reader(inputFile);
+    ASSERT_TRUE( d_reader.isOpened() );
 
-    reader.read(frame);
+    cv::gpu::GpuMat d_frame;
 
-    declare.time(20);
+    d_reader.read(d_frame);
 
     TEST_CYCLE_N(10)
     {
-        reader.read(frame);
+        d_reader.read(d_frame);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, VideoReader, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-#endif
+} // namespace