opencv
diff --git a/‎modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
Copy file name to clipboard
+49-141Lines changed: 49 additions & 141 deletions b/‎modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
Copy file name to clipboard
+49-141Lines changed: 49 additions & 141 deletions
diff --git a/‎modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
Copy file name to clipboard
+39-128Lines changed: 39 additions & 128 deletions b/‎modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
Copy file name to clipboard
+39-128Lines changed: 39 additions & 128 deletions
diff --git a/‎modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
Copy file name to clipboard
+50-103Lines changed: 50 additions & 103 deletions b/‎modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
Copy file name to clipboard
+50-103Lines changed: 50 additions & 103 deletions
diff --git a/‎modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
Copy file name to clipboard
+20-50Lines changed: 20 additions & 50 deletions b/‎modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
Copy file name to clipboard
+20-50Lines changed: 20 additions & 50 deletions
diff --git a/‎modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
Copy file name to clipboard
+11-20Lines changed: 11 additions & 20 deletions b/‎modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
Copy file name to clipboard
+11-20Lines changed: 11 additions & 20 deletions
@@ -19,26 +19,17 @@ namespace opencv_test
 INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest,
                         Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_obj()),
                                 Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30))));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
                         Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
@@ -49,81 +40,71 @@ INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
 
 INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
 
 // FIXME: Not supported by Fluid yet (no kernel implemented)
 INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(5e-3, 6).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2HSVTestFluid, RGB2HSVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestFluid, BayerGR2RGBTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUV422TestFluid, RGB2YUV422Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC2),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsTolerance(1).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -132,26 +113,23 @@ INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
 
 INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()),
                                 Values(3, 5)));
 
 INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
                                 Values(3))); // add kernel size=5 when implementation is ready
 
 INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -162,8 +140,7 @@ INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
 
 INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -174,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -185,8 +161,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -196,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -208,8 +182,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -220,8 +193,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -230,8 +202,7 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
 
 INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -240,7 +211,6 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
 INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),
 
@@ -12,28 +12,25 @@
 namespace
 {
 #define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
 {
 
 // FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now!
 INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
-                    Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                            Values(cv::Size(1280, 720),
-                                   cv::Size(640, 480),
-                                   cv::Size(128, 128)),
-                            Values(-1),
-                            Values(CORE_CPU),
-                            Values(AbsExact().to_compare_obj()),
-                            Values( ADD, SUB, DIV,
+                        Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
+                                ValuesIn(in_sizes),
+                                Values(-1),
+                                Values(CORE_CPU),
+                                Values(AbsExact().to_compare_obj()),
+                                Values( ADD, SUB, DIV,
                                     GT, LT, GE, LE, EQ, NE)));
 
 INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -44,19 +41,15 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
                                 Values( AND, OR, XOR )));
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -65,9 +58,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 }