diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp
index 5720e0c9d0..49a3274c99 100644
--- a/modules/gpu/test/test_color.cpp
+++ b/modules/gpu/test/test_color.cpp
@@ -2288,7 +2288,11 @@ GPU_TEST_P(CvtColor, BayerGR2Gray)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp
index 24a75c0235..8159ba72a9 100644
--- a/modules/gpu/test/test_copy_make_border.cpp
+++ b/modules/gpu/test/test_copy_make_border.cpp
@@ -90,6 +90,14 @@ GPU_TEST_P(CopyMakeBorder, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1),
+                    MatType(CV_8UC3),
+                    MatType(CV_8UC4),
+                    MatType(CV_32FC1),
+                    MatType(CV_32FC3),
+                    MatType(CV_32FC4)),
+#else
     testing::Values(MatType(CV_8UC1),
                     MatType(CV_8UC3),
                     MatType(CV_8UC4),
@@ -99,6 +107,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
                     MatType(CV_32FC1),
                     MatType(CV_32FC3),
                     MatType(CV_32FC4)),
+#endif
     testing::Values(Border(1), Border(10), Border(50)),
     ALL_BORDER_TYPES,
     WHOLE_SUBMAT));
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index b8b83ef10c..6ad36c094c 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -1344,7 +1344,11 @@ GPU_TEST_P(Abs, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1384,10 +1388,14 @@ GPU_TEST_P(Sqr, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1454,10 +1462,14 @@ GPU_TEST_P(Sqrt, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1524,10 +1536,14 @@ GPU_TEST_P(Log, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1604,10 +1620,14 @@ GPU_TEST_P(Exp, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32F)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1778,7 +1798,11 @@ GPU_TEST_P(Compare_Scalar, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Scalar, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     TYPES(CV_8U, CV_64F, 1, 4),
+#endif
     CmpCode::all(),
     WHOLE_SUBMAT));
 
@@ -1939,8 +1963,14 @@ GPU_TEST_P(Bitwise_Scalar, Xor)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U)),
+    testing::Values(Channels(1))
+#else
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
-    IMAGE_CHANNELS));
+    IMAGE_CHANNELS
+#endif
+));
 
 //////////////////////////////////////////////////////////////////////////////
 // RShift
@@ -2320,7 +2350,11 @@ GPU_TEST_P(Pow, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Pow, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_32F)),
+#else
     ALL_DEPTH,
+#endif
     WHOLE_SUBMAT));
 
 //////////////////////////////////////////////////////////////////////////////
@@ -2380,6 +2414,23 @@ GPU_TEST_P(AddWeighted, Accuracy)
     }
 }
 
+#ifdef OPENCV_TINY_GPU_MODULE
+INSTANTIATE_TEST_CASE_P(GPU_Core_1, AddWeighted, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    testing::Values(MatDepth(CV_8U)),
+    testing::Values(MatDepth(CV_8U)),
+    testing::Values(MatDepth(CV_8U)),
+    WHOLE_SUBMAT));
+
+INSTANTIATE_TEST_CASE_P(GPU_Core_2, AddWeighted, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    testing::Values(MatDepth(CV_32F)),
+    testing::Values(MatDepth(CV_32F)),
+    testing::Values(MatDepth(CV_32F)),
+    WHOLE_SUBMAT));
+#else
 INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
@@ -2387,6 +2438,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
     ALL_DEPTH,
     ALL_DEPTH,
     WHOLE_SUBMAT));
+#endif
 
 //////////////////////////////////////////////////////////////////////////////
 // GEMM
@@ -2956,12 +3008,17 @@ GPU_TEST_P(Norm, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U),
+                    MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_8S),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32S),
                     MatDepth(CV_32F)),
+#endif
     testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
     WHOLE_SUBMAT));
 
@@ -3139,7 +3196,11 @@ GPU_TEST_P(Sum, Sqr)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
+#else
     TYPES(CV_8U, CV_64F, 1, 4),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3513,11 +3574,19 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
         type = CV_MAKE_TYPE(depth, channels);
 
         if (reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN)
+        {
             dst_depth = depth;
+        }
+#ifndef OPENCV_TINY_GPU_MODULE
         else if (reduceOp == CV_REDUCE_SUM)
+        {
             dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
+        }
+#endif
         else
+        {
             dst_depth = depth < CV_32F ? CV_32F : depth;
+        }
 
         dst_type = CV_MAKE_TYPE(dst_depth, channels);
     }
@@ -3556,11 +3625,16 @@ GPU_TEST_P(Reduce, Cols)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U),
+                    MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
                     MatDepth(CV_32F),
                     MatDepth(CV_64F)),
+#endif
     ALL_CHANNELS,
     ALL_REDUCE_CODES,
     WHOLE_SUBMAT));
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index 697483657e..41f71d9bdf 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -310,6 +310,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Single)
     ASSERT_EQ(0, badCount);
 }
 
+#ifndef OPENCV_TINY_GPU_MODULE
 GPU_TEST_P(BruteForceMatcher, Match_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
@@ -363,6 +364,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Collection)
 
     ASSERT_EQ(0, badCount);
 }
+#endif
 
 GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
@@ -442,6 +444,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
     ASSERT_EQ(0, badCount);
 }
 
+#ifndef OPENCV_TINY_GPU_MODULE
 GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
@@ -565,6 +568,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
 
     ASSERT_EQ(0, badCount);
 }
+#endif
 
 GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
 {
@@ -615,6 +619,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
     }
 }
 
+#ifndef OPENCV_TINY_GPU_MODULE
 GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
@@ -693,10 +698,15 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
         ASSERT_EQ(0, badCount);
     }
 }
+#endif
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
     ALL_DEVICES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(NormCode(cv::NORM_L2)),
+#else
     testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)),
+#endif
     testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
     testing::Values(UseMask(false), UseMask(true))));
 
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index cbb6db8a2a..12aa91b602 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -167,7 +167,11 @@ GPU_TEST_P(Sobel, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+#endif
     IMAGE_CHANNELS,
     testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))),
     testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)),
@@ -230,7 +234,11 @@ GPU_TEST_P(Scharr, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+#endif
     IMAGE_CHANNELS,
     testing::Values(Deriv_X(0), Deriv_X(1)),
     testing::Values(Deriv_Y(0), Deriv_Y(1)),
@@ -304,8 +312,17 @@ GPU_TEST_P(GaussianBlur, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
+#else
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+#endif
     IMAGE_CHANNELS,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(KSize(cv::Size(3, 3)),
+                    KSize(cv::Size(5, 5)),
+                    KSize(cv::Size(7, 7))),
+#else
     testing::Values(KSize(cv::Size(3, 3)),
                     KSize(cv::Size(5, 5)),
                     KSize(cv::Size(7, 7)),
@@ -321,6 +338,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine(
                     KSize(cv::Size(27, 27)),
                     KSize(cv::Size(29, 29)),
                     KSize(cv::Size(31, 31))),
+#endif
     testing::Values(BorderType(cv::BORDER_REFLECT101),
                     BorderType(cv::BORDER_REPLICATE),
                     BorderType(cv::BORDER_CONSTANT),
@@ -568,7 +586,11 @@ GPU_TEST_P(Filter2D, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+#else
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+#endif
     testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), KSize(cv::Size(11, 11)), KSize(cv::Size(13, 13)), KSize(cv::Size(15, 15))),
     testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))),
     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)),
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index aa27bfe206..d834048cfe 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -359,7 +359,11 @@ GPU_TEST_P(Canny, Accuracy)
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(
     ALL_DEVICES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(AppertureSize(3)),
+#else
     testing::Values(AppertureSize(3), AppertureSize(5)),
+#endif
     testing::Values(L2gradient(false), L2gradient(true)),
     WHOLE_SUBMAT));
 
diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp
index 6b0540fc10..64bcacc48e 100644
--- a/modules/gpu/test/test_pyramids.cpp
+++ b/modules/gpu/test/test_pyramids.cpp
@@ -83,7 +83,11 @@ GPU_TEST_P(PyrDown, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////
@@ -123,7 +127,11 @@ GPU_TEST_P(PyrUp, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     WHOLE_SUBMAT));
 
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp
index eb4b9ece85..58635e4f3b 100644
--- a/modules/gpu/test/test_remap.cpp
+++ b/modules/gpu/test/test_remap.cpp
@@ -173,8 +173,13 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)),
+#else
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
+#endif
     WHOLE_SUBMAT));
 
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp
index 25f0f0e2bb..4adfd8d3ef 100644
--- a/modules/gpu/test/test_resize.cpp
+++ b/modules/gpu/test/test_resize.cpp
@@ -177,9 +177,17 @@ GPU_TEST_P(Resize, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     testing::Values(0.3, 0.5, 1.5, 2.0),
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
+#else
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
+#endif
     WHOLE_SUBMAT));
 
 /////////////////
@@ -224,7 +232,11 @@ GPU_TEST_P(ResizeSameAsHost, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     testing::Values(0.3, 0.5),
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_AREA)),
     WHOLE_SUBMAT));
@@ -232,7 +244,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc2, ResizeSameAsHost, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     testing::Values(0.3, 0.5, 1.5, 2.0),
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
     WHOLE_SUBMAT));
diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp
index 52ebd7f592..3a410f7921 100644
--- a/modules/gpu/test/test_threshold.cpp
+++ b/modules/gpu/test/test_threshold.cpp
@@ -86,7 +86,11 @@ GPU_TEST_P(Threshold, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
+#else
     testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
+#endif
     ThreshOp::all(),
     WHOLE_SUBMAT));
 
diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp
index 43bf0f6d9e..fdcacb0c58 100644
--- a/modules/gpu/test/test_warp_affine.cpp
+++ b/modules/gpu/test/test_warp_affine.cpp
@@ -225,10 +225,19 @@ GPU_TEST_P(WarpAffine, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     DIRECT_INVERSE,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
+#else
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
+#endif
     WHOLE_SUBMAT));
 
 ///////////////////////////////////////////////////////////////////
@@ -275,6 +284,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
     ALL_DEVICES,
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
     DIRECT_INVERSE,
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))));
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR))
+#else
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))
+#endif
+));
 
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp
index d225e58b66..e707eb4f41 100644
--- a/modules/gpu/test/test_warp_perspective.cpp
+++ b/modules/gpu/test/test_warp_perspective.cpp
@@ -228,10 +228,19 @@ GPU_TEST_P(WarpPerspective, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+#else
     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)),
+#endif
     DIRECT_INVERSE,
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
+    testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
+#else
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)),
+#endif
     WHOLE_SUBMAT));
 
 ///////////////////////////////////////////////////////////////////
@@ -278,6 +287,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(
     ALL_DEVICES,
     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
     DIRECT_INVERSE,
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))));
+#ifdef OPENCV_TINY_GPU_MODULE
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR))
+#else
+    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))
+#endif
+));
 
 #endif // HAVE_CUDA
diff --git a/modules/ts/include/opencv2/ts/gpu_test.hpp b/modules/ts/include/opencv2/ts/gpu_test.hpp
index 943a3536ca..01737bc951 100644
--- a/modules/ts/include/opencv2/ts/gpu_test.hpp
+++ b/modules/ts/include/opencv2/ts/gpu_test.hpp
@@ -215,6 +215,12 @@ namespace cvtest
 
     using perf::MatDepth;
 
+#ifdef OPENCV_TINY_GPU_MODULE
+    #define ALL_DEPTH testing::Values(MatDepth(CV_8U), MatDepth(CV_32F))
+
+    #define DEPTH_PAIRS testing::Values(std::make_pair(MatDepth(CV_8U), MatDepth(CV_8U)),   \
+                                        std::make_pair(MatDepth(CV_32F), MatDepth(CV_32F)))
+#else
     #define ALL_DEPTH testing::Values(MatDepth(CV_8U), MatDepth(CV_8S), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32S), MatDepth(CV_32F), MatDepth(CV_64F))
 
     #define DEPTH_PAIRS testing::Values(std::make_pair(MatDepth(CV_8U), MatDepth(CV_8U)),   \
@@ -242,6 +248,7 @@ namespace cvtest
                                         std::make_pair(MatDepth(CV_32F), MatDepth(CV_64F)), \
                                                                                             \
                                         std::make_pair(MatDepth(CV_64F), MatDepth(CV_64F)))
+#endif
 
     // Type
 
@@ -318,7 +325,11 @@ namespace cvtest
     CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA)
 
     CV_ENUM(BorderType, BORDER_REFLECT101, BORDER_REPLICATE, BORDER_CONSTANT, BORDER_REFLECT, BORDER_WRAP)
+#ifdef OPENCV_TINY_GPU_MODULE
+    #define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT))
+#else
     #define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP))
+#endif
 
     CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)