Merge pull request #14757 from andrey-golubev:core_tests_update

G-API: Introduce new approach to write accuracy tests (#14757)

* G-API: Introduce new common accuracy test fixture

* Enable Range<> to Seq<> implicit conversion

* Fix shadowing parameters

* Update license headers

* Rename ALIGNED_TYPE to SAME_TYPE

* Move MkRange to tests

* Fix TODO(agolubev) in test instantiations

* Squash simple fixture declarations in one line

* Remove unused line

* Fix Windows issues with macro expansion

* Choose between 1 or 2 matrix initialization

* Redesign common class behavior

Use "views" for GetParam() provided by GTest
base class instead of doing segregation
(with copy!) of common and specific parameters:
request common or specific parameter directly
by index from GetParam()-returned parameters

* Refine user-level API and usage of new test model

* Fix -fpermissive errors

* Remove unnecessary init calls

* Replace GCompileArgs member variable with func ptr

* Rename initMatsRandN to make its behavior explicit

Rename initMatsRandN to initMatrixRandN to eliminate confusion:
initMatsRandN only initialized first matrix (similarly to
initMatrixRandU)

* Fix common of initNothing

* Update copyright dates in missed files

* Add check for specific parameters

* Fix coment stlye

modules/gapi/perf/common/gapi_imgproc_perf_tests_inl.hpp

@@ -2,7 +2,7 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #ifndef OPENCV_GAPI_IMGPROC_PERF_TESTS_INL_HPP
@@ -68,7 +68,7 @@ PERF_TEST_P_(SepFilterPerfTest, TestPerformance)
     cv::Mat kernelY(kernSize, 1, CV_32F);
     randu(kernelX, -1, 1);
     randu(kernelY, -1, 1);
-    initMatsRandN(type, sz, dtype, false);
+    initMatrixRandN(type, sz, dtype, false);
 
     cv::Point anchor = cv::Point(-1, -1);
 
@@ -110,7 +110,7 @@ PERF_TEST_P_(Filter2DPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, borderType, dtype, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, dtype, false);
+    initMatrixRandN(type, sz, dtype, false);
 
     cv::Point anchor = {-1, -1};
     double delta = 0;
@@ -160,7 +160,7 @@ PERF_TEST_P_(BoxFilterPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, filterSize, sz, borderType, dtype, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, dtype, false);
+    initMatrixRandN(type, sz, dtype, false);
 
     cv::Point anchor = {-1, -1};
     bool normalize = true;
@@ -204,7 +204,7 @@ PERF_TEST_P_(BlurPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, filterSize, sz, borderType, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     cv::Point anchor = {-1, -1};
 
@@ -250,7 +250,7 @@ PERF_TEST_P_(GaussianBlurPerfTest, TestPerformance)
     cv::Size kSize = cv::Size(kernSize, kernSize);
     auto& rng = cv::theRNG();
     double sigmaX = rng();
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     // OpenCV code ///////////////////////////////////////////////////////////
     cv::GaussianBlur(in_mat1, out_mat_ocv, kSize, sigmaX);
@@ -289,7 +289,7 @@ PERF_TEST_P_(MedianBlurPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -330,7 +330,7 @@ PERF_TEST_P_(ErodePerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, kernType,  compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
 
@@ -373,7 +373,7 @@ PERF_TEST_P_(Erode3x3PerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, numIters, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3, 3));
 
@@ -416,7 +416,7 @@ PERF_TEST_P_(DilatePerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, kernType, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
 
@@ -459,7 +459,7 @@ PERF_TEST_P_(Dilate3x3PerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, numIters, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, type, false);
+    initMatrixRandN(type, sz, type, false);
 
     cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3, 3));
 
@@ -502,7 +502,7 @@ PERF_TEST_P_(SobelPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, dtype, dx, dy, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, dtype, false);
+    initMatrixRandN(type, sz, dtype, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -545,7 +545,7 @@ PERF_TEST_P_(SobelXYPerfTest, TestPerformance)
     cv::Mat out_mat_ocv2;
     cv::Mat out_mat_gapi2;
 
-    initMatsRandN(type, sz, dtype, false);
+    initMatrixRandN(type, sz, dtype, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -590,7 +590,7 @@ PERF_TEST_P_(CannyPerfTest, TestPerformance)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, thrLow, thrUp, apSize, l2gr, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, CV_8UC1, false);
+    initMatrixRandN(type, sz, CV_8UC1, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -628,7 +628,7 @@ PERF_TEST_P_(EqHistPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC1, sz, CV_8UC1, false);
+    initMatrixRandN(CV_8UC1, sz, CV_8UC1, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -666,7 +666,7 @@ PERF_TEST_P_(RGB2GrayPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC1, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC1, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -704,7 +704,7 @@ PERF_TEST_P_(BGR2GrayPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC1, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC1, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -742,7 +742,7 @@ PERF_TEST_P_(RGB2YUVPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -780,7 +780,7 @@ PERF_TEST_P_(YUV2RGBPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -818,7 +818,7 @@ PERF_TEST_P_(RGB2LabPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -856,7 +856,7 @@ PERF_TEST_P_(BGR2LUVPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -894,7 +894,7 @@ PERF_TEST_P_(LUV2BGRPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -932,7 +932,7 @@ PERF_TEST_P_(BGR2YUVPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_BGR2YUV);
 
@@ -962,7 +962,7 @@ PERF_TEST_P_(YUV2BGRPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
 
     cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_YUV2BGR);
 
@@ -990,7 +990,7 @@ PERF_TEST_P_(BayerGR2RGBPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC1, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC1, sz, CV_8UC3, false);
 
     cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_BayerGR2RGB);
 
@@ -1018,7 +1018,7 @@ PERF_TEST_P_(RGB2HSVPerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC3, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC3, false);
     cv::cvtColor(in_mat1, in_mat1, cv::COLOR_BGR2RGB);
 
     cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_RGB2HSV);
@@ -1047,7 +1047,7 @@ PERF_TEST_P_(RGB2YUV422PerfTest, TestPerformance)
     Size sz = get<1>(GetParam());
     cv::GCompileArgs compile_args = get<2>(GetParam());
 
-    initMatsRandN(CV_8UC3, sz, CV_8UC2, false);
+    initMatrixRandN(CV_8UC3, sz, CV_8UC2, false);
     cv::cvtColor(in_mat1, in_mat1, cv::COLOR_BGR2RGB);
 
     convertRGB2YUV422Ref(in_mat1, out_mat_ocv);

modules/gapi/test/common/gapi_core_tests.hpp

@@ -2,7 +2,7 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #ifndef OPENCV_GAPI_CORE_TESTS_HPP
@@ -46,16 +46,18 @@ struct PrintMathOpCoreParams
     std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
     {
         std::stringstream ss;
-        cv::Size sz = std::get<4>(info.param);
-        ss<<MathOperations[std::get<0>(info.param)]
-                    <<"_"<<std::get<1>(info.param)
-                    <<"_"<<std::get<2>(info.param)
-                    <<"_"<<(int)std::get<3>(info.param)
+        using AllParams = Params<mathOp,bool,double,bool>;
+        const AllParams::params_t& params = info.param;
+        cv::Size sz = AllParams::getCommon<1>(params);  // size
+        ss<<MathOperations[AllParams::getSpecific<0>(params)]  // mathOp
+                    <<"_"<<AllParams::getSpecific<1>(params)  // testWithScalar
+                    <<"_"<<AllParams::getCommon<0>(params)  // type
+                    <<"_"<<(int)AllParams::getSpecific<2>(params)  // scale
                     <<"_"<<sz.width
                     <<"x"<<sz.height
-                    <<"_"<<(std::get<5>(info.param)+1)
-                    <<"_"<<std::get<6>(info.param)
-                    <<"_"<<std::get<7>(info.param);
+                    <<"_"<<(AllParams::getCommon<2>(params)+1)  // dtype
+                    <<"_"<<AllParams::getCommon<3>(params)  // createOutputMatrices
+                    <<"_"<<AllParams::getSpecific<3>(params);  // doReverseOp
         return ss.str();
    }
 };
@@ -66,13 +68,15 @@ struct PrintCmpCoreParams
     std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
     {
         std::stringstream ss;
-        cv::Size sz = std::get<3>(info.param);
-        ss<<CompareOperations[std::get<0>(info.param)]
-                    <<"_"<<std::get<1>(info.param)
-                    <<"_"<<std::get<2>(info.param)
+        using AllParams = Params<CmpTypes,bool>;
+        const AllParams::params_t& params = info.param;
+        cv::Size sz = AllParams::getCommon<1>(params);  // size
+        ss<<CompareOperations[AllParams::getSpecific<0>(params)]  // CmpType
+                    <<"_"<<AllParams::getSpecific<1>(params)  // testWithScalar
+                    <<"_"<<AllParams::getCommon<0>(params)  // type
                     <<"_"<<sz.width
                     <<"x"<<sz.height
-                    <<"_"<<std::get<4>(info.param);
+                    <<"_"<<AllParams::getCommon<3>(params);  // createOutputMatrices
         return ss.str();
    }
 };
@@ -83,12 +87,14 @@ struct PrintBWCoreParams
     std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
     {
         std::stringstream ss;
-        cv::Size sz = std::get<2>(info.param);
-        ss<<BitwiseOperations[std::get<0>(info.param)]
-                    <<"_"<<std::get<1>(info.param)
+        using AllParams = Params<bitwiseOp>;
+        const AllParams::params_t& params = info.param;
+        cv::Size sz = AllParams::getCommon<1>(params);  // size
+        ss<<BitwiseOperations[AllParams::getSpecific<0>(params)]  // bitwiseOp
+                    <<"_"<<AllParams::getCommon<0>(params)  // type
                     <<"_"<<sz.width
                     <<"x"<<sz.height
-                    <<"_"<<std::get<3>(info.param);
+                    <<"_"<<AllParams::getCommon<3>(params);  // createOutputMatrices
         return ss.str();
    }
 };
@@ -99,56 +105,64 @@ struct PrintNormCoreParams
     std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
     {
         std::stringstream ss;
-        cv::Size sz = std::get<2>(info.param);
-        ss<<NormOperations[std::get<0>(info.param)]
-                    <<"_"<<std::get<1>(info.param)
+        using AllParams = Params<compare_scalar_f,NormTypes>;
+        const AllParams::params_t& params = info.param;
+        cv::Size sz = AllParams::getCommon<1>(params);  // size
+        ss<<NormOperations[AllParams::getSpecific<1>(params)]  // NormTypes
+                    <<"_"<<AllParams::getCommon<0>(params)  // type
                     <<"_"<<sz.width
                     <<"x"<<sz.height;
         return ss.str();
    }
 };
 
-struct MathOpTest        : public TestParams<std::tuple<mathOp,bool,int,double,cv::Size,int,bool,bool,cv::GCompileArgs>>{};
-struct MulDoubleTest     : public TestParams<std::tuple<int,cv::Size,int,bool,cv::GCompileArgs>>{};
-struct DivTest           : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>>{};
-struct DivCTest          : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>>{};
-struct MeanTest          : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct MaskTest          : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct Polar2CartTest    : public TestParams<std::tuple<cv::Size,bool, cv::GCompileArgs>> {};
-struct Cart2PolarTest    : public TestParams<std::tuple<cv::Size,bool, cv::GCompileArgs>> {};
-struct CmpTest           : public TestParams<std::tuple<CmpTypes,bool,int,cv::Size,bool, cv::GCompileArgs>>{};
-struct BitwiseTest       : public TestParams<std::tuple<bitwiseOp,int,cv::Size,bool, cv::GCompileArgs>>{};
-struct NotTest           : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct SelectTest        : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct MinTest           : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
-struct MaxTest           : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
-struct AbsDiffTest       : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
-struct AbsDiffCTest      : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct SumTest           : public TestParams<std::tuple<int, cv::Size,bool, compare_scalar_f, cv::GCompileArgs>> {};
-struct AddWeightedTest   : public TestParams<std::tuple<int,cv::Size,int,bool, compare_f,cv::GCompileArgs>>{};
-struct NormTest          : public TestParams<std::tuple<NormTypes,int,cv::Size, compare_scalar_f, cv::GCompileArgs>>{};
-struct IntegralTest      : public TestWithParam<std::tuple<int,cv::Size, cv::GCompileArgs>> {};
-struct ThresholdTest     : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};
-struct ThresholdOTTest   : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};
-struct InRangeTest       : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct Split3Test        : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
-struct Split4Test        : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
-struct ResizeTest        : public TestWithParam<std::tuple<compare_f, int, int, cv::Size, cv::Size, cv::GCompileArgs>> {};
-struct ResizeTestFxFy    : public TestWithParam<std::tuple<compare_f, int, int, cv::Size, double, double, cv::GCompileArgs>> {};
-struct Merge3Test        : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
-struct Merge4Test        : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
-struct RemapTest         : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct FlipTest          : public TestParams<std::tuple<int, int, cv::Size,bool, cv::GCompileArgs>> {};
-struct CropTest          : public TestParams<std::tuple<int,cv::Rect,cv::Size,bool, cv::GCompileArgs>> {};
-struct ConcatHorTest     : public TestWithParam<std::tuple<int, cv::Size, cv::GCompileArgs>> {};
-struct ConcatVertTest    : public TestWithParam<std::tuple<int, cv::Size, cv::GCompileArgs>> {};
-struct ConcatVertVecTest : public TestWithParam<std::tuple<int, cv::Size, cv::GCompileArgs>> {};
-struct ConcatHorVecTest  : public TestWithParam<std::tuple<int, cv::Size, cv::GCompileArgs>> {};
-struct LUTTest           : public TestParams<std::tuple<int, int, cv::Size,bool, cv::GCompileArgs>> {};
-struct ConvertToTest     : public TestParams<std::tuple<int, int, cv::Size, double, double, compare_f, cv::GCompileArgs>> {};
-struct PhaseTest         : public TestParams<std::tuple<int, cv::Size, bool, cv::GCompileArgs>> {};
-struct SqrtTest          : public TestParams<std::tuple<int, cv::Size, cv::GCompileArgs>> {};
-struct NormalizeTest : public TestParams<std::tuple<compare_f,MatType,cv::Size,double,double,int,MatType,bool,cv::GCompileArgs>> {};
+GAPI_TEST_FIXTURE(MathOpTest, initMatsRandU, FIXTURE_API(mathOp,bool,double,bool), 4,
+    opType, testWithScalar, scale, doReverseOp)
+GAPI_TEST_FIXTURE(MulDoubleTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(DivTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(DivCTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(MeanTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(MaskTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(Polar2CartTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(Cart2PolarTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(CmpTest, initMatsRandU, FIXTURE_API(CmpTypes,bool), 2, opType, testWithScalar)
+GAPI_TEST_FIXTURE(BitwiseTest, initMatsRandU, FIXTURE_API(bitwiseOp), 1, opType)
+GAPI_TEST_FIXTURE(NotTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(SelectTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(MinTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(MaxTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(AbsDiffTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(AbsDiffCTest, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(SumTest, initMatrixRandU, FIXTURE_API(compare_scalar_f), 1, cmpF)
+GAPI_TEST_FIXTURE(AddWeightedTest, initMatsRandU, FIXTURE_API(compare_f), 1, cmpF)
+GAPI_TEST_FIXTURE(NormTest, initMatrixRandU, FIXTURE_API(compare_scalar_f,NormTypes), 2,
+    cmpF, opType)
+GAPI_TEST_FIXTURE(IntegralTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(ThresholdTest, initMatrixRandU, FIXTURE_API(int), 1, tt)
+GAPI_TEST_FIXTURE(ThresholdOTTest, initMatrixRandU, FIXTURE_API(int), 1, tt)
+GAPI_TEST_FIXTURE(InRangeTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(Split3Test, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(Split4Test, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(ResizeTest, initNothing, FIXTURE_API(compare_f,int,cv::Size), 3,
+    cmpF, interp, sz_out)
+GAPI_TEST_FIXTURE(ResizeTestFxFy, initNothing, FIXTURE_API(compare_f,int,double,double), 4,
+    cmpF, interp, fx, fy)
+GAPI_TEST_FIXTURE(Merge3Test, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(Merge4Test, initMatsRandU, <>, 0)
+GAPI_TEST_FIXTURE(RemapTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(FlipTest, initMatrixRandU, FIXTURE_API(int), 1, flipCode)
+GAPI_TEST_FIXTURE(CropTest, initMatrixRandU, FIXTURE_API(cv::Rect), 1, rect_to)
+GAPI_TEST_FIXTURE(ConcatHorTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(ConcatVertTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(ConcatVertVecTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(ConcatHorVecTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(LUTTest, initNothing, <>, 0)
+GAPI_TEST_FIXTURE(ConvertToTest, initNothing, FIXTURE_API(compare_f, double, double), 3,
+    cmpF, alpha, beta)
+GAPI_TEST_FIXTURE(PhaseTest, initMatsRandU, FIXTURE_API(bool), 1, angle_in_degrees)
+GAPI_TEST_FIXTURE(SqrtTest, initMatrixRandU, <>, 0)
+GAPI_TEST_FIXTURE(NormalizeTest, initNothing, FIXTURE_API(compare_f,double,double,int,MatType), 5,
+    cmpF, a, b, norm_type, ddepth)
 } // opencv_test
 
 #endif //OPENCV_GAPI_CORE_TESTS_HPP

modules/gapi/test/common/gapi_core_tests_inl.hpp

@@ -2,7 +2,7 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #ifndef OPENCV_GAPI_CORE_TESTS_INL_HPP
@@ -16,15 +16,6 @@ namespace opencv_test
 
 TEST_P(MathOpTest, MatricesAccuracyTest )
 {
-    mathOp opType = ADD;
-    int type = 0, dtype = 0;
-    cv::Size sz;
-    double scale = 1; // mul, div
-    bool testWithScalar = false, initOutMatr = false, doReverseOp = false;
-    cv::GCompileArgs compile_args;
-    std::tie(opType, testWithScalar, type, scale, sz, dtype, initOutMatr, doReverseOp, compile_args) = GetParam();
-    initMatsRandU(type, sz, dtype, initOutMatr);
-
     // G-API code & corresponding OpenCV code ////////////////////////////////
     cv::GMat in1, in2, out;
     if( testWithScalar )
@@ -82,7 +73,7 @@ TEST_P(MathOpTest, MatricesAccuracyTest )
         }
         }
         cv::GComputation c(GIn(in1, sc1), GOut(out));
-        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args));
+        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
     }
     else
     {
@@ -118,7 +109,7 @@ TEST_P(MathOpTest, MatricesAccuracyTest )
             FAIL() << "no such math operation type for matrix and matrix!";
         }}
         cv::GComputation c(GIn(in1, in2), GOut(out));
-        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
     }
 
     // Comparison //////////////////////////////////////////////////////////////
@@ -148,22 +139,14 @@ TEST_P(MathOpTest, MatricesAccuracyTest )
 
 TEST_P(MulDoubleTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    int dtype = std::get<2>(param);
-    cv::Size sz_in = std::get<1>(param);
-    bool initOut = std::get<3>(param);
-
     auto& rng = cv::theRNG();
     double d = rng.uniform(0.0, 10.0);
-    auto compile_args = std::get<4>(param);
-    initMatrixRandU(type, sz_in, dtype, initOut);
 
     // G-API code ////////////////////////////////////////////////////////////
     cv::GMat in1, out;
     out = cv::gapi::mulC(in1, d, dtype);
     cv::GComputation c(in1, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
 
     // OpenCV code ///////////////////////////////////////////////////////////
     cv::multiply(in_mat1, d, out_mat_ocv, 1, dtype);
@@ -187,26 +170,19 @@ TEST_P(MulDoubleTest, AccuracyTest)
 #else
     EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
 #endif
-    EXPECT_EQ(out_mat_gapi.size(), sz_in);
+    EXPECT_EQ(out_mat_gapi.size(), sz);
 }
 
 TEST_P(DivTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pull/12826
 {
-    int type = 0, dtype = 0;
-    cv::Size sz_in;
-    bool initOut = false;
-    cv::GCompileArgs compile_args;
-    std::tie(type, sz_in, dtype, initOut, compile_args) = GetParam();
-
-    initMatrixRandU(type, sz_in, dtype, initOut);
-    in_mat2 = cv::Mat(sz_in, type);
+    in_mat2 = cv::Mat(sz, type);
     in_mat2.setTo(cv::Scalar::all(0));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::div(in1, in2, 1.0, dtype);
     cv::GComputation c(GIn(in1, in2), GOut(out));
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -216,19 +192,12 @@ TEST_P(DivTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pul
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(DivCTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pull/12826
 {
-    int type = 0, dtype = 0;
-    cv::Size sz_in;
-    bool initOut = false;
-    cv::GCompileArgs compile_args;
-    std::tie(type, sz_in, dtype, initOut, compile_args) = GetParam();
-
-    initMatrixRandU(type, sz_in, dtype, initOut);
     sc = cv::Scalar::all(0);
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -237,7 +206,7 @@ TEST_P(DivCTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pu
     auto out = cv::gapi::divC(in1, sc1, dtype);
     cv::GComputation c(GIn(in1, sc1), GOut(out));
 
-    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -247,19 +216,13 @@ TEST_P(DivCTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pu
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        cv::Mat zeros = cv::Mat::zeros(sz_in, type);
+        cv::Mat zeros = cv::Mat::zeros(sz, type);
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != zeros));
     }
 }
 
 TEST_P(MeanTest, AccuracyTest)
 {
-    int type = 0;
-    bool initOut = false;
-    cv::Size sz_in;
-    cv::GCompileArgs compile_args;
-    std::tie(type, sz_in, initOut, compile_args) = GetParam();
-    initMatrixRandU(type, sz_in, initOut);
     cv::Scalar out_norm;
     cv::Scalar out_norm_ocv;
 
@@ -268,7 +231,7 @@ TEST_P(MeanTest, AccuracyTest)
     auto out = cv::gapi::mean(in);
 
     cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_mat1), cv::gout(out_norm), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_norm), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         out_norm_ocv = cv::mean(in_mat1);
@@ -281,14 +244,7 @@ TEST_P(MeanTest, AccuracyTest)
 
 TEST_P(MaskTest, AccuracyTest)
 {
-    int type = 0;
-    bool initOut = false;
-    cv::Size sz_in;
-    cv::GCompileArgs compile_args;
-    std::tie(type, sz_in, initOut, compile_args) = GetParam();
-    initMatrixRandU(type, sz_in, type, initOut);
-
-    in_mat2 = cv::Mat(sz_in, CV_8UC1);
+    in_mat2 = cv::Mat(sz, CV_8UC1);
     cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
     in_mat2 = in_mat2 > 128;
 
@@ -297,7 +253,7 @@ TEST_P(MaskTest, AccuracyTest)
     auto out = cv::gapi::mask(in, m);
 
     cv::GComputation c(cv::GIn(in, m), cv::GOut(out));
-    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), std::move(compile_args));
+    c.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat_gapi), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         out_mat_ocv = cv::Mat::zeros(in_mat1.size(), in_mat1.type());
@@ -311,17 +267,12 @@ TEST_P(MaskTest, AccuracyTest)
 
 TEST_P(Polar2CartTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<0>(param);
-    auto compile_args = std::get<2>(param);
-    initMatsRandU(CV_32FC1, sz_in, CV_32FC1, std::get<1>(param));
-
     cv::Mat out_mat2;
     cv::Mat out_mat_ocv2;
-    if(std::get<1>(param) == true)
+    if(createOutputMatrices)
     {
-        out_mat2 = cv::Mat(sz_in, CV_32FC1);
-        out_mat_ocv2 = cv::Mat(sz_in, CV_32FC1);
+        out_mat2 = cv::Mat(sz, dtype);
+        out_mat_ocv2 = cv::Mat(sz, dtype);
     }
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -329,7 +280,7 @@ TEST_P(Polar2CartTest, AccuracyTest)
     std::tie(out1, out2) = cv::gapi::polarToCart(in1, in2);
 
     cv::GComputation c(GIn(in1, in2), GOut(out1, out2));
-    c.apply(gin(in_mat1,in_mat2), gout(out_mat_gapi, out_mat2), std::move(compile_args));
+    c.apply(gin(in_mat1,in_mat2), gout(out_mat_gapi, out_mat2), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         cv::polarToCart(in_mat1, in_mat2, out_mat_ocv, out_mat_ocv2);
@@ -361,19 +312,14 @@ TEST_P(Polar2CartTest, AccuracyTest)
 
         EXPECT_EQ(0, cv::countNonZero(difx > 1e-6*absx));
         EXPECT_EQ(0, cv::countNonZero(dify > 1e-6*absy));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(Cart2PolarTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<0>(param);
-    auto compile_args = std::get<2>(param);
-    initMatsRandU(CV_32FC1, sz_in, CV_32FC1, std::get<1>(param));
-
-    cv::Mat out_mat2(sz_in, CV_32FC1);
-    cv::Mat out_mat_ocv2(sz_in, CV_32FC1);
+    cv::Mat out_mat2(sz, dtype);
+    cv::Mat out_mat_ocv2(sz, dtype);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2, out1, out2;
@@ -414,20 +360,12 @@ TEST_P(Cart2PolarTest, AccuracyTest)
         //        (expected relative accuracy like 1e-6)
         EXPECT_EQ(0, cv::countNonZero(difm > 1e-6*absm));
         EXPECT_EQ(0, cv::countNonZero(difa > 1e-3*absa));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(CmpTest, AccuracyTest)
 {
-    CmpTypes opType = CMP_EQ;
-    int type = 0;
-    cv::Size sz;
-    bool testWithScalar = false, initOutMatr = false;
-    cv::GCompileArgs compile_args;
-    std::tie(opType, testWithScalar, type, sz, initOutMatr, compile_args) = GetParam();
-    initMatsRandU(type, sz, CV_8U, initOutMatr);
-
     // G-API code & corresponding OpenCV code ////////////////////////////////
     cv::GMat in1, out;
     if( testWithScalar )
@@ -447,7 +385,7 @@ TEST_P(CmpTest, AccuracyTest)
         cv::compare(in_mat1, sc, out_mat_ocv, opType);
 
         cv::GComputation c(GIn(in1, in2), GOut(out));
-        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args));
+        c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
     }
     else
     {
@@ -466,7 +404,7 @@ TEST_P(CmpTest, AccuracyTest)
         cv::compare(in_mat1, in_mat2, out_mat_ocv, opType);
 
         cv::GComputation c(GIn(in1, in2), GOut(out));
-        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+        c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
     }
 
     // Comparison //////////////////////////////////////////////////////////////
@@ -478,14 +416,6 @@ TEST_P(CmpTest, AccuracyTest)
 
 TEST_P(BitwiseTest, AccuracyTest)
 {
-    bitwiseOp opType = AND;
-    int type = 0;
-    cv::Size sz;
-    bool initOutMatr = false;
-    cv::GCompileArgs compile_args;
-    std::tie(opType, type, sz, initOutMatr, compile_args) = GetParam();
-    initMatsRandU(type, sz, type, initOutMatr);
-
     // G-API code & corresponding OpenCV code ////////////////////////////////
     cv::GMat in1, in2, out;
     switch(opType)
@@ -514,7 +444,7 @@ TEST_P(BitwiseTest, AccuracyTest)
         }
     }
     cv::GComputation c(GIn(in1, in2), GOut(out));
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // Comparison //////////////////////////////////////////////////////////////
     {
@@ -525,17 +455,12 @@ TEST_P(BitwiseTest, AccuracyTest)
 
 TEST_P(NotTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatrixRandU(std::get<0>(param), sz_in, std::get<0>(param), std::get<2>(param));
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
     auto out = cv::gapi::bitwise_not(in);
     cv::GComputation c(in, out);
 
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -544,18 +469,13 @@ TEST_P(NotTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(SelectTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatsRandU(type, sz_in, type, std::get<2>(param));
-    cv::Mat in_mask(sz_in, CV_8UC1);
+    cv::Mat in_mask(sz, CV_8UC1);
     cv::randu(in_mask, cv::Scalar::all(0), cv::Scalar::all(255));
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -563,7 +483,7 @@ TEST_P(SelectTest, AccuracyTest)
     auto out = cv::gapi::select(in1, in2, in3);
     cv::GComputation c(GIn(in1, in2, in3), GOut(out));
 
-    c.apply(gin(in_mat1, in_mat2, in_mask), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2, in_mask), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -573,23 +493,18 @@ TEST_P(SelectTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(MinTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatsRandU(std::get<0>(param), sz_in, std::get<0>(param), std::get<2>(param));
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::min(in1, in2);
     cv::GComputation c(GIn(in1, in2), GOut(out));
 
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -598,23 +513,18 @@ TEST_P(MinTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(MaxTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatsRandU(std::get<0>(param), sz_in, std::get<0>(param), std::get<2>(param));
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::max(in1, in2);
     cv::GComputation c(GIn(in1, in2), GOut(out));
 
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -623,23 +533,18 @@ TEST_P(MaxTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(AbsDiffTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatsRandU(std::get<0>(param), sz_in, std::get<0>(param), std::get<2>(param));
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::absDiff(in1, in2);
     cv::GComputation c(GIn(in1, in2), GOut(out));
 
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -648,24 +553,19 @@ TEST_P(AbsDiffTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(AbsDiffCTest, AccuracyTest)
 {
-    auto param = GetParam();
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatsRandU(std::get<0>(param), sz_in, std::get<0>(param), std::get<2>(param));
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1;
     cv::GScalar sc1;
     auto out = cv::gapi::absDiffC(in1, sc1);
     cv::GComputation c(cv::GIn(in1, sc1), cv::GOut(out));
 
-    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -674,20 +574,12 @@ TEST_P(AbsDiffCTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(SumTest, AccuracyTest)
 {
-    auto param = GetParam();
-    compare_scalar_f cmpF = get<3>(GetParam());
-    MatType type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<4>(param);
-    initMatrixRandU(type, sz_in, type, std::get<2>(param));
-
-
     cv::Scalar out_sum;
     cv::Scalar out_sum_ocv;
 
@@ -696,7 +588,7 @@ TEST_P(SumTest, AccuracyTest)
     auto out = cv::gapi::sum(in);
 
     cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_mat1), cv::gout(out_sum), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_sum), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         out_sum_ocv = cv::sum(in_mat1);
@@ -709,25 +601,17 @@ TEST_P(SumTest, AccuracyTest)
 
 TEST_P(AddWeightedTest, AccuracyTest)
 {
-    int type = 0, dtype = 0;
-    cv::Size sz_in;
-    bool initOut = false;
-    cv::GCompileArgs compile_args;
-    compare_f cmpF;
-    std::tie(type, sz_in, dtype, initOut, cmpF, compile_args) = GetParam();
-
     auto& rng = cv::theRNG();
     double alpha = rng.uniform(0.0, 1.0);
     double beta = rng.uniform(0.0, 1.0);
     double gamma = rng.uniform(0.0, 1.0);
-    initMatsRandU(type, sz_in, dtype, initOut);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::addWeighted(in1, alpha, in2, beta, gamma, dtype);
     cv::GComputation c(GIn(in1, in2), GOut(out));
 
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -735,20 +619,11 @@ TEST_P(AddWeightedTest, AccuracyTest)
     }
     // Comparison //////////////////////////////////////////////////////////////
     EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    EXPECT_EQ(out_mat_gapi.size(), sz_in);
-
+    EXPECT_EQ(out_mat_gapi.size(), sz);
 }
 
 TEST_P(NormTest, AccuracyTest)
 {
-    compare_scalar_f cmpF;
-    NormTypes opType = NORM_INF;
-    int type = 0;
-    cv::Size sz;
-    cv::GCompileArgs compile_args;
-    std::tie(opType, type, sz, cmpF, compile_args) = GetParam();
-    initMatrixRandU(type, sz, type, false);
-
     cv::Scalar out_norm;
     cv::Scalar out_norm_ocv;
 
@@ -764,7 +639,7 @@ TEST_P(NormTest, AccuracyTest)
     }
     out_norm_ocv = cv::norm(in_mat1, opType);
     cv::GComputation c(GIn(in1), GOut(out));
-    c.apply(gin(in_mat1), gout(out_norm), std::move(compile_args));
+    c.apply(gin(in_mat1), gout(out_norm), getCompileArgs());
 
     // Comparison //////////////////////////////////////////////////////////////
     {
@@ -774,16 +649,12 @@ TEST_P(NormTest, AccuracyTest)
 
 TEST_P(IntegralTest, AccuracyTest)
 {
-    int type = std::get<0>(GetParam());
-    cv::Size sz_in = std::get<1>(GetParam());
-    auto compile_args = std::get<2>(GetParam());
-
     int type_out = (type == CV_8U) ? CV_32SC1 : CV_64FC1;
-    cv::Mat in_mat1(sz_in, type);
+    in_mat1 = cv::Mat(sz, type);
 
     cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
 
-    cv::Size sz_out = cv::Size(sz_in.width + 1, sz_in.height + 1);
+    cv::Size sz_out = cv::Size(sz.width + 1, sz.height + 1);
     cv::Mat out_mat1(sz_out, type_out);
     cv::Mat out_mat_ocv1(sz_out, type_out);
 
@@ -795,7 +666,7 @@ TEST_P(IntegralTest, AccuracyTest)
     std::tie(out1, out2)  = cv::gapi::integral(in1, type_out, CV_64FC1);
     cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2));
 
-    c.apply(cv::gin(in_mat1), cv::gout(out_mat1, out_mat2), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_mat1, out_mat2), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -810,15 +681,8 @@ TEST_P(IntegralTest, AccuracyTest)
 
 TEST_P(ThresholdTest, AccuracyTestBinary)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-    int tt = std::get<2>(param);
-
-    auto compile_args = std::get<4>(param);
     cv::Scalar thr = initScalarRandU(50);
     cv::Scalar maxval = initScalarRandU(50) + cv::Scalar(50, 50, 50, 50);
-    initMatrixRandU(type, sz_in, type, std::get<3>(param));
     cv::Scalar out_scalar;
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -827,7 +691,7 @@ TEST_P(ThresholdTest, AccuracyTestBinary)
     out = cv::gapi::threshold(in1, th1, mv1, tt);
     cv::GComputation c(GIn(in1, th1, mv1), GOut(out));
 
-    c.apply(gin(in_mat1, thr, maxval), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, thr, maxval), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -835,21 +699,14 @@ TEST_P(ThresholdTest, AccuracyTestBinary)
     }
     // Comparison //////////////////////////////////////////////////////////////
     {
-        ASSERT_EQ(out_mat_gapi.size(), sz_in);
+        ASSERT_EQ(out_mat_gapi.size(), sz);
         EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_L1));
     }
 }
 
 TEST_P(ThresholdOTTest, AccuracyTestOtsu)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-    int tt = std::get<2>(param);
-
-    auto compile_args = std::get<4>(param);
     cv::Scalar maxval = initScalarRandU(50) + cv::Scalar(50, 50, 50, 50);
-    initMatrixRandU(type, sz_in, type, std::get<3>(param));
     cv::Scalar out_gapi_scalar;
     double ocv_res;
 
@@ -859,7 +716,7 @@ TEST_P(ThresholdOTTest, AccuracyTestOtsu)
     std::tie<cv::GMat, cv::GScalar>(out, scout) = cv::gapi::threshold(in1, mv1, tt);
     cv::GComputation c(cv::GIn(in1, mv1), cv::GOut(out, scout));
 
-    c.apply(gin(in_mat1, maxval), gout(out_mat_gapi, out_gapi_scalar), std::move(compile_args));
+    c.apply(gin(in_mat1, maxval), gout(out_mat_gapi, out_gapi_scalar), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -868,21 +725,15 @@ TEST_P(ThresholdOTTest, AccuracyTestOtsu)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
         EXPECT_EQ(ocv_res, out_gapi_scalar.val[0]);
     }
 }
 
 TEST_P(InRangeTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-
-    auto compile_args = std::get<3>(param);
     cv::Scalar thrLow = initScalarRandU(100);
     cv::Scalar thrUp = initScalarRandU(100) + cv::Scalar(100, 100, 100, 100);
-    initMatrixRandU(type, sz_in, type, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1;
@@ -890,7 +741,7 @@ TEST_P(InRangeTest, AccuracyTest)
     auto out = cv::gapi::inRange(in1, th1, mv1);
     cv::GComputation c(GIn(in1, th1, mv1), GOut(out));
 
-    c.apply(gin(in_mat1, thrLow, thrUp), gout(out_mat_gapi), std::move(compile_args));
+    c.apply(gin(in_mat1, thrLow, thrUp), gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -899,26 +750,22 @@ TEST_P(InRangeTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(Split3Test, AccuracyTest)
 {
-    cv::Size sz_in = std::get<0>(GetParam());
-    auto compile_args = std::get<1>(GetParam());
-    initMatrixRandU(CV_8UC3, sz_in, CV_8UC1);
-
-    cv::Mat out_mat2 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat3 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat_ocv2 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat_ocv3 = cv::Mat(sz_in, CV_8UC1);
+    cv::Mat out_mat2 = cv::Mat(sz, dtype);
+    cv::Mat out_mat3 = cv::Mat(sz, dtype);
+    cv::Mat out_mat_ocv2 = cv::Mat(sz, dtype);
+    cv::Mat out_mat_ocv3 = cv::Mat(sz, dtype);
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, out1, out2, out3;
     std::tie(out1, out2, out3)  = cv::gapi::split3(in1);
     cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2, out3));
 
-    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         std::vector<cv::Mat> out_mats_ocv = {out_mat_ocv, out_mat_ocv2, out_mat_ocv3};
@@ -934,22 +781,19 @@ TEST_P(Split3Test, AccuracyTest)
 
 TEST_P(Split4Test, AccuracyTest)
 {
-    cv::Size sz_in = std::get<0>(GetParam());
-    auto compile_args = std::get<1>(GetParam());
-    initMatrixRandU(CV_8UC4, sz_in, CV_8UC1);
-    cv::Mat out_mat2 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat3 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat4 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat_ocv2 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat_ocv3 = cv::Mat(sz_in, CV_8UC1);
-    cv::Mat out_mat_ocv4 = cv::Mat(sz_in, CV_8UC1);
+    cv::Mat out_mat2 = cv::Mat(sz, dtype);
+    cv::Mat out_mat3 = cv::Mat(sz, dtype);
+    cv::Mat out_mat4 = cv::Mat(sz, dtype);
+    cv::Mat out_mat_ocv2 = cv::Mat(sz, dtype);
+    cv::Mat out_mat_ocv3 = cv::Mat(sz, dtype);
+    cv::Mat out_mat_ocv4 = cv::Mat(sz, dtype);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, out1, out2, out3, out4;
     std::tie(out1, out2, out3, out4)  = cv::gapi::split4(in1);
     cv::GComputation c(cv::GIn(in1), cv::GOut(out1, out2, out3, out4));
 
-    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3, out_mat4), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi, out_mat2, out_mat3, out_mat4), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         std::vector<cv::Mat> out_mats_ocv = {out_mat_ocv, out_mat_ocv2, out_mat_ocv3, out_mat_ocv4};
@@ -996,31 +840,17 @@ static void ResizeAccuracyTest(compare_f cmpF, int type, int interp, cv::Size sz
 
 TEST_P(ResizeTest, AccuracyTest)
 {
-    compare_f cmpF;
-    int type = 0, interp = 0;
-    cv::Size sz_in, sz_out;
-    cv::GCompileArgs compile_args;
-    std::tie(cmpF, type, interp, sz_in, sz_out, compile_args) = GetParam();
-    ResizeAccuracyTest(cmpF, type, interp, sz_in, sz_out, 0.0, 0.0, std::move(compile_args));
+    ResizeAccuracyTest(cmpF, type, interp, sz, sz_out, 0.0, 0.0, getCompileArgs());
 }
 
 TEST_P(ResizeTestFxFy, AccuracyTest)
 {
-    compare_f cmpF;
-    int type = 0, interp = 0;
-    cv::Size sz_in;
-    double fx = 0.0, fy = 0.0;
-    cv::GCompileArgs compile_args;
-    std::tie(cmpF, type, interp, sz_in, fx, fy, compile_args) = GetParam();
-    ResizeAccuracyTest(cmpF, type, interp, sz_in, cv::Size{0, 0}, fx, fy, std::move(compile_args));
+    ResizeAccuracyTest(cmpF, type, interp, sz, cv::Size{0, 0}, fx, fy, getCompileArgs());
 }
 
 TEST_P(Merge3Test, AccuracyTest)
 {
-    cv::Size sz_in = std::get<0>(GetParam());
-    initMatsRandU(CV_8UC1, sz_in, CV_8UC3);
-    auto compile_args = std::get<1>(GetParam());
-    cv::Mat in_mat3(sz_in,  CV_8UC1);
+    cv::Mat in_mat3(sz, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
 
@@ -1031,7 +861,7 @@ TEST_P(Merge3Test, AccuracyTest)
     auto out = cv::gapi::merge3(in1, in2, in3);
 
     cv::GComputation c(cv::GIn(in1, in2, in3), cv::GOut(out));
-    c.apply(cv::gin(in_mat1, in_mat2, in_mat3), cv::gout(out_mat_gapi), std::move(compile_args));
+    c.apply(cv::gin(in_mat1, in_mat2, in_mat3), cv::gout(out_mat_gapi), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         std::vector<cv::Mat> in_mats_ocv = {in_mat1, in_mat2, in_mat3};
@@ -1045,11 +875,8 @@ TEST_P(Merge3Test, AccuracyTest)
 
 TEST_P(Merge4Test, AccuracyTest)
 {
-    cv::Size sz_in = std::get<0>(GetParam());
-    initMatsRandU(CV_8UC1, sz_in, CV_8UC4);
-    auto compile_args = std::get<1>(GetParam());
-    cv::Mat in_mat3(sz_in,  CV_8UC1);
-    cv::Mat in_mat4(sz_in,  CV_8UC1);
+    cv::Mat in_mat3(sz, type);
+    cv::Mat in_mat4(sz, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
 
@@ -1061,7 +888,7 @@ TEST_P(Merge4Test, AccuracyTest)
     auto out = cv::gapi::merge4(in1, in2, in3, in4);
 
     cv::GComputation c(cv::GIn(in1, in2, in3, in4), cv::GOut(out));
-    c.apply(cv::gin(in_mat1, in_mat2, in_mat3, in_mat4), cv::gout(out_mat_gapi), std::move(compile_args));
+    c.apply(cv::gin(in_mat1, in_mat2, in_mat3, in_mat4), cv::gout(out_mat_gapi), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         std::vector<cv::Mat> in_mats_ocv = {in_mat1, in_mat2, in_mat3, in_mat4};
@@ -1075,12 +902,7 @@ TEST_P(Merge4Test, AccuracyTest)
 
 TEST_P(RemapTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_in = std::get<1>(param);
-    auto compile_args = std::get<3>(param);
-    initMatrixRandU(type, sz_in, type, std::get<2>(param));
-    cv::Mat in_map1(sz_in,  CV_16SC2);
+    cv::Mat in_map1(sz, CV_16SC2);
     cv::Mat in_map2 = cv::Mat();
     cv::randu(in_map1, cv::Scalar::all(0), cv::Scalar::all(255));
     cv::Scalar bv = cv::Scalar();
@@ -1090,7 +912,7 @@ TEST_P(RemapTest, AccuracyTest)
     auto out = cv::gapi::remap(in1, in_map1, in_map2, cv::INTER_NEAREST,  cv::BORDER_REPLICATE, bv);
     cv::GComputation c(in1, out);
 
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -1099,25 +921,18 @@ TEST_P(RemapTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(FlipTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    int flipCode =  std::get<1>(param);
-    cv::Size sz_in = std::get<2>(param);
-    initMatrixRandU(type, sz_in, type, false);
-    auto compile_args = std::get<4>(GetParam());
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
     auto out = cv::gapi::flip(in, flipCode);
 
     cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         cv::flip(in_mat1, out_mat_ocv, flipCode);
@@ -1125,24 +940,17 @@ TEST_P(FlipTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(CropTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Rect rect_to = std::get<1>(param);
-    cv::Size sz_in = std::get<2>(param);
-    auto compile_args = std::get<4>(param);
-
-    initMatrixRandU(type, sz_in, type, false);
     cv::Size sz_out = cv::Size(rect_to.width, rect_to.height);
-    if( std::get<3>(param) == true )
+    if(createOutputMatrices)
     {
-        out_mat_gapi = cv::Mat(sz_out, type);
-        out_mat_ocv = cv::Mat(sz_out, type);
+        out_mat_gapi = cv::Mat(sz_out, dtype);
+        out_mat_ocv = cv::Mat(sz_out, dtype);
     }
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -1150,7 +958,7 @@ TEST_P(CropTest, AccuracyTest)
     auto out = cv::gapi::crop(in, rect_to);
 
     cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         cv::Mat(in_mat1, rect_to).copyTo(out_mat_ocv);
@@ -1164,17 +972,14 @@ TEST_P(CropTest, AccuracyTest)
 
 TEST_P(ConcatHorTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_out = std::get<1>(param);
-    auto compile_args = std::get<2>(param);
+    cv::Size sz_out = sz;
 
     int wpart = sz_out.width / 4;
     cv::Size sz_in1 = cv::Size(wpart, sz_out.height);
     cv::Size sz_in2 = cv::Size(sz_out.width - wpart, sz_out.height);
 
-    cv::Mat in_mat1 (sz_in1, type );
-    cv::Mat in_mat2 (sz_in2, type);
+    in_mat1 = cv::Mat(sz_in1, type );
+    in_mat2 = cv::Mat(sz_in2, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
 
@@ -1182,17 +987,17 @@ TEST_P(ConcatHorTest, AccuracyTest)
     cv::randn(in_mat2, mean, stddev);
 
     cv::Mat out_mat(sz_out, type);
-    cv::Mat out_mat_ocv(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::concatHor(in1, in2);
 
     cv::GComputation c(GIn(in1, in2), GOut(out));
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
-        cv::hconcat(in_mat1, in_mat2, out_mat_ocv );
+        cv::hconcat(in_mat1, in_mat2, out_mat_ocv);
     }
     // Comparison //////////////////////////////////////////////////////////////
     {
@@ -1202,17 +1007,14 @@ TEST_P(ConcatHorTest, AccuracyTest)
 
 TEST_P(ConcatVertTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_out = std::get<1>(param);
-    auto compile_args = std::get<2>(param);
+    cv::Size sz_out = sz;
 
     int hpart = sz_out.height * 2/3;
     cv::Size sz_in1 = cv::Size(sz_out.width, hpart);
     cv::Size sz_in2 = cv::Size(sz_out.width, sz_out.height - hpart);
 
-    cv::Mat in_mat1 (sz_in1, type);
-    cv::Mat in_mat2 (sz_in2, type);
+    in_mat1 = cv::Mat(sz_in1, type);
+    in_mat2 = cv::Mat(sz_in2, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
 
@@ -1220,14 +1022,14 @@ TEST_P(ConcatVertTest, AccuracyTest)
     cv::randn(in_mat2, mean, stddev);
 
     cv::Mat out_mat(sz_out, type);
-    cv::Mat out_mat_ocv(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in1, in2;
     auto out = cv::gapi::concatVert(in1, in2);
 
     cv::GComputation c(GIn(in1, in2), GOut(out));
-    c.apply(gin(in_mat1, in_mat2), gout(out_mat), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2), gout(out_mat), getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         cv::vconcat(in_mat1, in_mat2, out_mat_ocv );
@@ -1240,10 +1042,7 @@ TEST_P(ConcatVertTest, AccuracyTest)
 
 TEST_P(ConcatVertVecTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_out = std::get<1>(param);
-    auto compile_args = std::get<2>(param);
+    cv::Size sz_out = sz;
 
     int hpart1 = sz_out.height * 2/5;
     int hpart2 = sz_out.height / 5;
@@ -1251,9 +1050,9 @@ TEST_P(ConcatVertVecTest, AccuracyTest)
     cv::Size sz_in2 = cv::Size(sz_out.width, hpart2);
     cv::Size sz_in3 = cv::Size(sz_out.width, sz_out.height - hpart1 - hpart2);
 
-    cv::Mat in_mat1 (sz_in1, type);
-    cv::Mat in_mat2 (sz_in2, type);
-    cv::Mat in_mat3 (sz_in3, type);
+    in_mat1 = cv::Mat(sz_in1, type);
+    in_mat2 = cv::Mat(sz_in2, type);
+    cv::Mat in_mat3(sz_in3, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
 
@@ -1262,7 +1061,7 @@ TEST_P(ConcatVertVecTest, AccuracyTest)
     cv::randn(in_mat3, mean, stddev);
 
     cv::Mat out_mat(sz_out, type);
-    cv::Mat out_mat_ocv(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
 
     // G-API code //////////////////////////////////////////////////////////////
     std::vector <cv::GMat> mats(3);
@@ -1271,7 +1070,7 @@ TEST_P(ConcatVertVecTest, AccuracyTest)
     std::vector <cv::Mat> cvmats = {in_mat1, in_mat2, in_mat3};
 
     cv::GComputation c({mats[0], mats[1], mats[2]}, {out});
-    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -1285,10 +1084,7 @@ TEST_P(ConcatVertVecTest, AccuracyTest)
 
 TEST_P(ConcatHorVecTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type = std::get<0>(param);
-    cv::Size sz_out = std::get<1>(param);
-    auto compile_args = std::get<2>(param);
+    cv::Size sz_out = sz;
 
     int wpart1 = sz_out.width / 3;
     int wpart2 = sz_out.width / 4;
@@ -1296,8 +1092,8 @@ TEST_P(ConcatHorVecTest, AccuracyTest)
     cv::Size sz_in2 = cv::Size(wpart2, sz_out.height);
     cv::Size sz_in3 = cv::Size(sz_out.width - wpart1 - wpart2, sz_out.height);
 
-    cv::Mat in_mat1 (sz_in1, type);
-    cv::Mat in_mat2 (sz_in2, type);
+    in_mat1 = cv::Mat(sz_in1, type);
+    in_mat2 = cv::Mat(sz_in2, type);
     cv::Mat in_mat3 (sz_in3, type);
     cv::Scalar mean = cv::Scalar::all(127);
     cv::Scalar stddev = cv::Scalar::all(40.f);
@@ -1307,7 +1103,7 @@ TEST_P(ConcatHorVecTest, AccuracyTest)
     cv::randn(in_mat3, mean, stddev);
 
     cv::Mat out_mat(sz_out, type);
-    cv::Mat out_mat_ocv(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
 
     // G-API code //////////////////////////////////////////////////////////////
     std::vector <cv::GMat> mats(3);
@@ -1316,7 +1112,7 @@ TEST_P(ConcatHorVecTest, AccuracyTest)
     std::vector <cv::Mat> cvmats = {in_mat1, in_mat2, in_mat3};
 
     cv::GComputation c({mats[0], mats[1], mats[2]}, {out});
-    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), std::move(compile_args));
+    c.apply(gin(in_mat1, in_mat2, in_mat3), gout(out_mat), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {
@@ -1330,14 +1126,11 @@ TEST_P(ConcatHorVecTest, AccuracyTest)
 
 TEST_P(LUTTest, AccuracyTest)
 {
-    auto param = GetParam();
-    int type_mat = std::get<0>(param);
-    int type_lut = std::get<1>(param);
+    int type_mat = type;
+    int type_lut = dtype;
     int type_out = CV_MAKETYPE(CV_MAT_DEPTH(type_lut), CV_MAT_CN(type_mat));
-    cv::Size sz_in = std::get<2>(param);
-    auto compile_args = std::get<4>(GetParam());
 
-    initMatrixRandU(type_mat, sz_in, type_out);
+    initMatrixRandU(type_mat, sz, type_out);
     cv::Size sz_lut = cv::Size(1, 256);
     cv::Mat in_lut(sz_lut, type_lut);
     cv::randu(in_lut, cv::Scalar::all(0), cv::Scalar::all(255));
@@ -1347,7 +1140,7 @@ TEST_P(LUTTest, AccuracyTest)
     auto out = cv::gapi::LUT(in, in_lut);
 
     cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         cv::LUT(in_mat1, in_lut, out_mat_ocv);
@@ -1355,29 +1148,23 @@ TEST_P(LUTTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(ConvertToTest, AccuracyTest)
 {
-    int type_mat = -1, depth_to = -1;
-    double alpha = 1.0, beta = 0.0;
-    cv::Size sz_in;
-    cv::GCompileArgs compile_args;
-    compare_f cmpF;
-
-    std::tie(type_mat, depth_to, sz_in, alpha, beta, cmpF, compile_args) = GetParam();
-
+    int type_mat = type;
+    int depth_to = dtype;
     int type_out = CV_MAKETYPE(depth_to, CV_MAT_CN(type_mat));
-    initMatrixRandU(type_mat, sz_in, type_out);
+    initMatrixRandU(type_mat, sz, type_out);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
     auto out = cv::gapi::convertTo(in, depth_to, alpha, beta);
 
     cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
     // OpenCV code /////////////////////////////////////////////////////////////
     {
         in_mat1.convertTo(out_mat_ocv, depth_to, alpha, beta);
@@ -1385,25 +1172,18 @@ TEST_P(ConvertToTest, AccuracyTest)
     // Comparison //////////////////////////////////////////////////////////////
     {
         EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz_in);
+        EXPECT_EQ(out_mat_gapi.size(), sz);
     }
 }
 
 TEST_P(PhaseTest, AccuracyTest)
 {
-    int img_type = -1;
-    cv::Size img_size;
-    bool angle_in_degrees = false;
-    cv::GCompileArgs compile_args;
-    std::tie(img_type, img_size, angle_in_degrees, compile_args) = GetParam();
-    initMatsRandU(img_type, img_size, img_type);
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in_x, in_y;
     auto out = cv::gapi::phase(in_x, in_y, angle_in_degrees);
 
     cv::GComputation c(in_x, in_y, out);
-    c.apply(in_mat1, in_mat2, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, in_mat2, out_mat_gapi, getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     cv::phase(in_mat1, in_mat2, out_mat_ocv, angle_in_degrees);
@@ -1417,18 +1197,12 @@ TEST_P(PhaseTest, AccuracyTest)
 
 TEST_P(SqrtTest, AccuracyTest)
 {
-    int img_type = -1;
-    cv::Size img_size;
-    cv::GCompileArgs compile_args;
-    std::tie(img_type, img_size, compile_args) = GetParam();
-    initMatrixRandU(img_type, img_size, img_type);
-
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
     auto out = cv::gapi::sqrt(in);
 
     cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
+    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     cv::sqrt(in_mat1, out_mat_ocv);
@@ -1442,27 +1216,14 @@ TEST_P(SqrtTest, AccuracyTest)
 
 TEST_P(NormalizeTest, Test)
 {
-    auto param = GetParam();
-
-    compare_f cmpF;
-    MatType type, ddepth;
-    cv::Size sz;
-    double a = 0 , b = 0;
-    int norm_type = 0;
-    bool createOut = 0;
-    cv::GCompileArgs compile_args;
-
-    std::tie(cmpF, type, sz, a, b, norm_type, ddepth, createOut, compile_args) = GetParam();
-    int dtype = CV_MAKETYPE(ddepth, CV_MAT_CN(type));
-
-    initMatsRandN(type, sz, dtype, createOut);
+    initMatrixRandN(type, sz, CV_MAKETYPE(ddepth, CV_MAT_CN(type)), createOutputMatrices);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
     auto out = cv::gapi::normalize(in, a, b, norm_type, ddepth);
 
     cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi), std::move(compile_args));
+    c.apply(cv::gin(in_mat1), cv::gout(out_mat_gapi), getCompileArgs());
 
     // OpenCV code /////////////////////////////////////////////////////////////
     {

modules/gapi/test/common/gapi_imgproc_tests_inl.hpp

@@ -2,7 +2,7 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #ifndef OPENCV_GAPI_IMGPROC_TESTS_INL_HPP
@@ -61,7 +61,7 @@ TEST_P(Filter2DTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, borderType, dtype, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, dtype, initOut);
+    initMatrixRandN(type, sz, dtype, initOut);
 
     cv::Point anchor = {-1, -1};
     double delta = 0;
@@ -97,7 +97,7 @@ TEST_P(BoxFilterTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, filterSize, sz, borderType, dtype, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, dtype, initOut);
+    initMatrixRandN(type, sz, dtype, initOut);
 
     cv::Point anchor = {-1, -1};
     bool normalize = true;
@@ -133,7 +133,7 @@ TEST_P(SepFilterTest, AccuracyTest)
     cv::Mat kernelY(kernSize, 1, CV_32F);
     randu(kernelX, -1, 1);
     randu(kernelY, -1, 1);
-    initMatsRandN(type, sz, dtype, initOut);
+    initMatrixRandN(type, sz, dtype, initOut);
 
     cv::Point anchor = cv::Point(-1, -1);
 
@@ -163,7 +163,7 @@ TEST_P(BlurTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, filterSize, sz, borderType, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Point anchor = {-1, -1};
 
@@ -193,7 +193,7 @@ TEST_P(GaussianBlurTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF,type, kernSize, sz, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Size kSize = cv::Size(kernSize, kernSize);
     double sigmaX = rand();
@@ -224,7 +224,7 @@ TEST_P(MedianBlurTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -252,7 +252,7 @@ TEST_P(ErodeTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, kernType, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
 
@@ -282,7 +282,7 @@ TEST_P(Erode3x3Test, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, initOut, numIters, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3,3));
 
@@ -312,7 +312,7 @@ TEST_P(DilateTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, kernType, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
 
@@ -342,7 +342,7 @@ TEST_P(Dilate3x3Test, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, initOut, numIters, compile_args) = GetParam();
-    initMatsRandN(type, sz, type, initOut);
+    initMatrixRandN(type, sz, type, initOut);
 
     cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3,3));
 
@@ -373,7 +373,7 @@ TEST_P(SobelTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, kernSize, sz, dtype, dx, dy, initOut, compile_args) = GetParam();
-    initMatsRandN(type, sz, dtype, initOut);
+    initMatrixRandN(type, sz, dtype, initOut);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -404,7 +404,7 @@ TEST_P(SobelXYTest, AccuracyTest)
     cv::Mat out_mat_ocv2;
     cv::Mat out_mat_gapi2;
 
-    initMatsRandN(type, sz, dtype);
+    initMatrixRandN(type, sz, dtype);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -441,7 +441,7 @@ TEST_P(EqHistTest, AccuracyTest)
     bool initOut = false;
     cv::GCompileArgs compile_args;
     std::tie(cmpF, sz, initOut, compile_args) = GetParam();
-    initMatsRandN(CV_8UC1, sz, CV_8UC1, initOut);
+    initMatrixRandN(CV_8UC1, sz, CV_8UC1, initOut);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -471,7 +471,7 @@ TEST_P(CannyTest, AccuracyTest)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, type, sz, thrLow, thrUp, apSize, l2gr, initOut, compile_args) = GetParam();
 
-    initMatsRandN(type, sz, CV_8UC1, initOut);
+    initMatrixRandN(type, sz, CV_8UC1, initOut);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -495,7 +495,7 @@ TEST_P(RGB2GrayTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC1, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC1, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -519,7 +519,7 @@ TEST_P(BGR2GrayTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC1, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC1, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -543,7 +543,7 @@ TEST_P(RGB2YUVTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -567,7 +567,7 @@ TEST_P(YUV2RGBTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
 
     // G-API code //////////////////////////////////////////////////////////////
@@ -594,7 +594,7 @@ TEST_P(NV12toRGBTest, AccuracyTest)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, sz, compile_args) = GetParam();
 
-    initMatsRandN(CV_8UC1, sz, CV_8UC3);
+    initMatrixRandN(CV_8UC1, sz, CV_8UC3);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in_y;
@@ -625,7 +625,7 @@ TEST_P(NV12toBGRTest, AccuracyTest)
     cv::GCompileArgs compile_args;
     std::tie(cmpF, sz, compile_args) = GetParam();
 
-    initMatsRandN(CV_8UC1, sz, CV_8UC3);
+    initMatrixRandN(CV_8UC1, sz, CV_8UC3);
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in_y;
@@ -654,7 +654,7 @@ TEST_P(RGB2LabTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -678,7 +678,7 @@ TEST_P(BGR2LUVTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -702,7 +702,7 @@ TEST_P(LUV2BGRTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -726,7 +726,7 @@ TEST_P(BGR2YUVTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -750,7 +750,7 @@ TEST_P(YUV2BGRTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -774,7 +774,7 @@ TEST_P(RGB2HSVTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -798,7 +798,7 @@ TEST_P(BayerGR2RGBTest, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC1, std::get<1>(param), CV_8UC3, std::get<2>(param));
+    initMatrixRandN(CV_8UC1, std::get<1>(param), CV_8UC3, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;
@@ -822,7 +822,7 @@ TEST_P(RGB2YUV422Test, AccuracyTest)
     auto param = GetParam();
     auto compile_args = std::get<3>(param);
     compare_f cmpF = std::get<0>(param);
-    initMatsRandN(CV_8UC3, std::get<1>(param), CV_8UC2, std::get<2>(param));
+    initMatrixRandN(CV_8UC3, std::get<1>(param), CV_8UC2, std::get<2>(param));
 
     // G-API code //////////////////////////////////////////////////////////////
     cv::GMat in;

modules/gapi/test/common/gapi_tests_common.hpp

@@ -2,13 +2,20 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
+#ifndef OPENCV_GAPI_TESTS_COMMON_HPP
+#define OPENCV_GAPI_TESTS_COMMON_HPP
 
 #include <iostream>
+#include <tuple>
+#include <type_traits>
 
 #include <opencv2/ts.hpp>
 #include <opencv2/gapi.hpp>
+#include <opencv2/gapi/util/util.hpp>
+
+#include "gapi_tests_helpers.hpp"
 
 namespace
 {
@@ -41,6 +48,15 @@ public:
         return cv::Scalar(s1, s2, s3, s4);
     }
 
+    void initOutMats(cv::Size sz_in, int dtype)
+    {
+        if (dtype != -1)
+        {
+            out_mat_gapi = cv::Mat(sz_in, dtype);
+            out_mat_ocv = cv::Mat(sz_in, dtype);
+        }
+    }
+
     void initMatsRandU(int type, cv::Size sz_in, int dtype, bool createOutputMatrices = true)
     {
         in_mat1 = cv::Mat(sz_in, type);
@@ -50,10 +66,9 @@ public:
         cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
         cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
 
-        if (createOutputMatrices && dtype != -1)
+        if (createOutputMatrices)
         {
-            out_mat_gapi = cv::Mat (sz_in, dtype);
-            out_mat_ocv = cv::Mat (sz_in, dtype);
+            initOutMats(sz_in, dtype);
         }
     }
 
@@ -62,28 +77,28 @@ public:
         in_mat1 = cv::Mat(sz_in, type);
 
         sc = initScalarRandU(100);
-
         cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
 
-        if (createOutputMatrices && dtype != -1)
+        if (createOutputMatrices)
         {
-            out_mat_gapi = cv::Mat (sz_in, dtype);
-            out_mat_ocv = cv::Mat (sz_in, dtype);
+            initOutMats(sz_in, dtype);
         }
     }
 
-    void initMatsRandN(int type, cv::Size sz_in, int dtype, bool createOutputMatrices = true)
+    void initMatrixRandN(int type, cv::Size sz_in, int dtype, bool createOutputMatrices = true)
     {
         in_mat1 = cv::Mat(sz_in, type);
         cv::randn(in_mat1, cv::Scalar::all(127), cv::Scalar::all(40.f));
 
-        if (createOutputMatrices  && dtype != -1)
+        if (createOutputMatrices)
         {
-            out_mat_gapi = cv::Mat(sz_in, dtype);
-            out_mat_ocv = cv::Mat(sz_in, dtype);
+            initOutMats(sz_in, dtype);
         }
     }
 
+    // empty function intended to show that nothing is to be initialized via TestFunctional methods
+    void initNothing(int, cv::Size, int, bool = true) {}
+
     static cv::Mat nonZeroPixels(const cv::Mat& mat)
     {
         int channels = mat.channels();
@@ -117,6 +132,100 @@ using compare_f = std::function<bool(const cv::Mat &a, const cv::Mat &b)>;
 
 using compare_scalar_f = std::function<bool(const cv::Scalar &a, const cv::Scalar &b)>;
 
+// Universal parameter wrapper for common (pre-defined) and specific (user-defined) parameters
+template<typename ...SpecificParams>
+struct Params
+{
+    using gcomp_args_function_t = cv::GCompileArgs(*)();
+    // TODO: delete bool (createOutputMatrices) from common parameters
+    using common_params_t = std::tuple<int, cv::Size, int, bool, gcomp_args_function_t>;
+    using specific_params_t = std::tuple<SpecificParams...>;
+    using params_t = std::tuple<int, cv::Size, int, bool, gcomp_args_function_t, SpecificParams...>;
+    static constexpr const size_t common_params_size = std::tuple_size<common_params_t>::value;
+    static constexpr const size_t specific_params_size = std::tuple_size<specific_params_t>::value;
+
+    template<size_t I>
+    static const typename std::tuple_element<I, common_params_t>::type&
+    getCommon(const params_t& t)
+    {
+        static_assert(I < common_params_size, "Index out of range");
+        return std::get<I>(t);
+    }
+
+    template<size_t I>
+    static const typename std::tuple_element<I, specific_params_t>::type&
+    getSpecific(const params_t& t)
+    {
+        static_assert(specific_params_size > 0,
+            "Impossible to call this function: no specific parameters specified");
+        static_assert(I < specific_params_size, "Index out of range");
+        return std::get<common_params_size + I>(t);
+    }
+};
+
+// Base class for test fixtures
+template<typename ...SpecificParams>
+struct TestWithParamBase : TestFunctional,
+    TestWithParam<typename Params<SpecificParams...>::params_t>
+{
+    using AllParams = Params<SpecificParams...>;
+
+    MatType type = getCommonParam<0>();
+    cv::Size sz = getCommonParam<1>();
+    MatType dtype = getCommonParam<2>();
+    bool createOutputMatrices = getCommonParam<3>();
+
+    TestWithParamBase()
+    {
+        if (dtype == SAME_TYPE) { dtype = type; }
+    }
+
+    // Get common (pre-defined) parameter value by index
+    template<size_t I>
+    inline auto getCommonParam() const
+        -> decltype(AllParams::template getCommon<I>(this->GetParam()))
+    {
+        return AllParams::template getCommon<I>(this->GetParam());
+    }
+
+    // Get specific (user-defined) parameter value by index
+    template<size_t I>
+    inline auto getSpecificParam() const
+        -> decltype(AllParams::template getSpecific<I>(this->GetParam()))
+    {
+        return AllParams::template getSpecific<I>(this->GetParam());
+    }
+
+    // Return G-API compile arguments specified for test fixture
+    inline cv::GCompileArgs getCompileArgs() const
+    {
+        return getCommonParam<4>()();
+    }
+};
+
+/**
+ * @private
+ * @brief Create G-API test fixture with TestWithParamBase base class
+ * @param Fixture   test fixture name
+ * @param InitF     callable that will initialize default available members (from TestFunctional)
+ * @param API       base class API. Specifies types of user-defined parameters. If there are no such
+ *                  parameters, empty angle brackets ("<>") must be specified.
+ * @param Number    number of user-defined parameters (corresponds to the number of types in API).
+ *                  if there are no such parameters, 0 must be specified.
+ * @param ...       list of names of user-defined parameters. if there are no parameters, the list
+ *                  must be empty.
+ */
+#define GAPI_TEST_FIXTURE(Fixture, InitF, API, Number, ...) \
+    struct Fixture : public TestWithParamBase API { \
+        static_assert(Number == AllParams::specific_params_size, \
+            "Number of user-defined parameters doesn't match size of __VA_ARGS__"); \
+        __WRAP_VAARGS(DEFINE_SPECIFIC_PARAMS_##Number(__VA_ARGS__)) \
+        Fixture() { InitF(type, sz, dtype, createOutputMatrices); } \
+    };
+
+// Wrapper for test fixture API. Use to specify multiple types.
+// Example: FIXTURE_API(int, bool) expands to <int, bool>
+#define FIXTURE_API(...) <__VA_ARGS__>
 
 template<typename T>
 struct Wrappable
@@ -341,3 +450,5 @@ namespace
         return os << "compare_scalar_f";
     }
 }
+
+#endif //OPENCV_GAPI_TESTS_COMMON_HPP

modules/gapi/test/common/gapi_tests_helpers.hpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019 Intel Corporation
+
+#ifndef OPENCV_GAPI_TESTS_HELPERS_HPP
+#define OPENCV_GAPI_TESTS_HELPERS_HPP
+
+#include <tuple>
+#include <limits>
+
+namespace opencv_test
+{
+
+// out_type == in_type in matrices initialization if out_type is marked as SAME_TYPE
+enum {
+    // TODO: why is it different from -1?
+    SAME_TYPE = std::numeric_limits<int>::max()
+};
+
+// Ensure correct __VA_ARGS__ expansion on Windows
+#define __WRAP_VAARGS(x) x
+
+#define __TUPLE_PARAM_TYPE(i) std::tuple_element<i, AllParams::specific_params_t>::type
+
+// implementation of recursive in-class declaration and initialization of member variables
+#define __DEFINE_PARAMS_IMPL1(index, param_name) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>();
+
+#define __DEFINE_PARAMS_IMPL2(index, param_name, ...) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>(); \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL1(index+1, __VA_ARGS__))
+
+#define __DEFINE_PARAMS_IMPL3(index, param_name, ...) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>(); \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL2(index+1, __VA_ARGS__))
+
+#define __DEFINE_PARAMS_IMPL4(index, param_name, ...) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>(); \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL3(index+1, __VA_ARGS__))
+
+#define __DEFINE_PARAMS_IMPL5(index, param_name, ...) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>(); \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL4(index+1, __VA_ARGS__))
+
+#define __DEFINE_PARAMS_IMPL6(index, param_name, ...) \
+    __TUPLE_PARAM_TYPE(index) param_name = getSpecificParam<index>(); \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL5(index+1, __VA_ARGS__))
+
+// user interface to define member variables of specified names
+#define DEFINE_SPECIFIC_PARAMS_0()
+
+#define DEFINE_SPECIFIC_PARAMS_1(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL1(0, __VA_ARGS__))
+
+#define DEFINE_SPECIFIC_PARAMS_2(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL2(0, __VA_ARGS__))
+
+#define DEFINE_SPECIFIC_PARAMS_3(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL3(0, __VA_ARGS__))
+
+#define DEFINE_SPECIFIC_PARAMS_4(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL4(0, __VA_ARGS__))
+
+#define DEFINE_SPECIFIC_PARAMS_5(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL5(0, __VA_ARGS__))
+
+#define DEFINE_SPECIFIC_PARAMS_6(...) \
+    __WRAP_VAARGS(__DEFINE_PARAMS_IMPL6(0, __VA_ARGS__))
+} // namespace opencv_test
+
+#endif //OPENCV_GAPI_TESTS_HELPERS_HPP

modules/gapi/test/cpu/gapi_core_tests_cpu.cpp

@@ -2,74 +2,76 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #include "../test_precomp.hpp"
 #include "../common/gapi_core_tests.hpp"
 #include <opencv2/gapi/cpu/core.hpp>
 
-#define CORE_CPU cv::gapi::core::cpu::kernels()
+namespace
+{
+    #define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); }
+}  // anonymous namespace
 
 namespace opencv_test
 {
 
-
 // FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
 INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
-                        Combine(Values(ADD, MUL),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(1.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(false),
-                                Values(cv::compile_args(CORE_CPU))),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU),
+                                Values(ADD, MUL),
+                                testing::Bool(),
+                                Values(1.0),
+                                Values(false)),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
-                        Combine(Values(MUL),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(1.0, 0.5, 2.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(false),
-                                Values(cv::compile_args(CORE_CPU))),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU),
+                                Values(MUL),
+                                testing::Bool(),
+                                Values(1.0, 0.5, 2.0),
+                                Values(false)),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
-                        Combine(Values(SUB),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values (1.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU),
+                                Values(SUB),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))),
+                                Values (1.0),
+                                testing::Bool()),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
-                        Combine(Values(DIV),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values (1.0, 0.5, 2.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU),
+                                Values(DIV),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))),
+                                Values (1.0, 0.5, 2.0),
+                                testing::Bool()),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
@@ -78,8 +80,8 @@ INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -87,8 +89,8 @@ INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -96,81 +98,94 @@ INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(-1, SAME_TYPE),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
                         Combine(Values(CV_32F, CV_32FC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(true),
+                                Values(CORE_CPU),
+                                testing::Bool()));
 
 INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
                         Combine(Values(CV_32F, CV_32FC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
-                        Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_8U),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))),
+                                Values(CORE_CPU),
+                                Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
+                                testing::Bool()),
                         opencv_test::PrintCmpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
-                        Combine(Values(AND, OR, XOR),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))),
+                                Values(CORE_CPU),
+                                Values(AND, OR, XOR)),
                         opencv_test::PrintBWCoreParams());
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
@@ -178,50 +193,56 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
- /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
                                 //Values(1e-5),
-                                Values(AbsToleranceScalar(1e-5).to_compare_f()),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU),
+                                Values(AbsToleranceScalar(1e-5).to_compare_f())));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -230,18 +251,20 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU),
+                                Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f())));
 
 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
-                        Combine(Values(NORM_INF, NORM_L1, NORM_L2),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
+                                Values(false),
                                 //Values(1e-5),
+                                Values(CORE_CPU),
                                 Values(AbsToleranceScalar(1e-5).to_compare_f()),
-                                Values(cv::compile_args(CORE_CPU))),
+                                Values(NORM_INF, NORM_L1, NORM_L2)),
                         opencv_test::PrintNormCoreParams());
 
 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
@@ -249,25 +272,30 @@ INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU),
+                                Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
+                                    cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
                         Combine(Values(CV_8UC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU),
+                                Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
 
 
 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
@@ -275,147 +303,177 @@ INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC3),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC4),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
-                        Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_CPU),
+                                Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
+                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
                                 Values(cv::Size(64,64),
-                                       cv::Size(30,30)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                       cv::Size(30,30))));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
-                        Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_CPU),
+                                Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
+                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
                                 Values(0.5, 0.1),
-                                Values(0.5, 0.1),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(0.5, 0.1)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC3),
+                                Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC4),
+                                Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(0,1,-1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ Values(false),
+                                Values(CORE_CPU),
+                                Values(0,1,-1)));
 
 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ Values(false),
+                                Values(CORE_CPU),
+                                Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(CV_8UC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC1),
+/*init output matrices or not*/ Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
                         Combine(Values(CV_8UC3),
-                                Values(CV_8UC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(CV_8UC3),
+/*init output matrices or not*/ Values(true),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
-                        Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(CV_8U, CV_16U, CV_16S, CV_32F),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(2.5, 1.0, -1.0),
-                                Values(250.0, 0.0, -128.0),
+                                Values(CV_8U, CV_16U, CV_16S, CV_32F),
+                                Values(false),
+                                Values(CORE_CPU),
                                 Values(AbsExact().to_compare_f()),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(2.5, 1.0, -1.0),
+                                Values(250.0, 0.0, -128.0)));
 
 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
-                        Combine(Values(AbsExact().to_compare_f()),
-                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
+                        Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480)),
+                                Values(-1),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_CPU),
+                                Values(AbsExact().to_compare_f()),
                                 Values(0.0, 15.0),
                                 Values(1.0, 120.0, 255.0),
                                 Values(NORM_MINMAX, NORM_INF, NORM_L1, NORM_L2),
-                                Values(-1, CV_8U, CV_16U, CV_16S, CV_32F),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_CPU))));
+                                Values(-1, CV_8U, CV_16U, CV_16S, CV_32F)));
 }

modules/gapi/test/cpu/gapi_core_tests_fluid.cpp

@@ -2,32 +2,34 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #include "../test_precomp.hpp"
 #include "../common/gapi_core_tests.hpp"
 
-namespace opencv_test
+namespace
 {
+    #define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); }
+}  // anonymous namespace
 
-#define CORE_FLUID cv::gapi::core::fluid::kernels()
-
+namespace opencv_test
+{
 
 // FIXME: Windows accuracy problems after recent update!
 INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
-                        Combine(Values(ADD, SUB, DIV, MUL),
-                                testing::Bool(),
-                                Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(1.0),
+                        Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
                                 Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values(-1, CV_8U, CV_32F),
                                 testing::Bool(),
+                                Values(CORE_FLUID),
+                                Values(ADD, SUB, DIV, MUL),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))),
+                                Values(1.0),
+                                testing::Bool()),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
@@ -37,7 +39,7 @@ INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
                                        cv::Size(128, 128)),
                                 Values(-1), // FIXME: extend with more types
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
@@ -46,33 +48,36 @@ INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
                                        cv::Size(128, 128)),
                                 Values(CV_8U, CV_32F),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
-                        Combine(Values(AND, OR, XOR),
-                                Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
+                        Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))),
+                                Values(CORE_FLUID),
+                                Values(AND, OR, XOR)),
                         opencv_test::PrintBWCoreParams());
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
@@ -81,8 +86,9 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
@@ -90,8 +96,9 @@ INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
@@ -99,19 +106,21 @@ INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
-                        Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
-                                testing::Bool(),
-                                Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
+                        Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
                                 Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_8U),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))),
+                                Values(CORE_FLUID),
+                                Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
+                                testing::Bool()),
                         opencv_test::PrintCmpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
@@ -121,57 +130,70 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
                                        cv::Size(128, 128)),
                                 Values(-1, CV_8U, CV_32F),
                                 testing::Bool(),
-                                Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
                                 //Values(0.5000005),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID),
+                                Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f())));
 
 INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(CV_8UC1),
                                 Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CV_8UC1),
+/*init output matrices or not*/ Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1),
-                                Values(CV_8U, CV_16U, CV_32F),
                                 Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(2.5, 1.0, -1.0),
-                                Values(250.0, 0.0, -128.0),
+                                Values(CV_8U, CV_16U, CV_32F),
+                                Values(true),
+                                Values(CORE_FLUID),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(2.5, 1.0, -1.0),
+                                Values(250.0, 0.0, -128.0)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC3),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC4),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test,
-                        Combine(Values(cv::Size(1920, 1080),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CV_8UC3),
+                                Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test,
-                        Combine(Values(cv::Size(1920, 1080),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1920, 1080),
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CV_8UC4),
+                                Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
@@ -179,37 +201,46 @@ INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest,
                         Combine(Values(CV_32F, CV_32FC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(SAME_TYPE),
+                                Values(true),
+                                Values(CORE_FLUID),
+                                testing::Bool()));
 
 INSTANTIATE_TEST_CASE_P(SqrtFluid, SqrtTest,
                         Combine(Values(CV_32F, CV_32FC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(SAME_TYPE),
+                                Values(true),
+                                Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
@@ -217,11 +248,12 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
+                                testing::Bool(),
+                                Values(CORE_FLUID),
                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV,
                                        cv::THRESH_TRUNC,
-                                       cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
-                                testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                       cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)));
 
 INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
@@ -229,25 +261,27 @@ INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
                                        cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                Values(CORE_FLUID)));
 
-INSTANTIATE_TEST_CASE_P(
-                        ResizeTestFluid, ResizeTest,
-                        Combine(Values(AbsExact().to_compare_f()),
-                                Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
-                                Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
+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(false),
+                                Values(CORE_FLUID),
+                                Values(AbsExact().to_compare_f()),
+                                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)),
-                                Values(cv::compile_args(CORE_FLUID))));
+                                       cv::Size(30, 30))));
 
 //----------------------------------------------------------------------
 // FIXME: Clean-up test configurations which are enabled already
@@ -476,7 +510,7 @@ INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool()));
+/*init output matrices or not*/ Values(true)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
                         Combine(Values(CV_8UC3),
@@ -484,7 +518,7 @@ INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool()));
+/*init output matrices or not*/ Values(true)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1),

modules/gapi/test/gpu/gapi_core_tests_gpu.cpp

@@ -2,72 +2,75 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
 
 
 #include "../test_precomp.hpp"
 #include "../common/gapi_core_tests.hpp"
 
-#define CORE_GPU cv::gapi::core::gpu::kernels()
+namespace
+{
+    #define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); }
+}  // anonymous namespace
 
 namespace opencv_test
 {
 
 // FIXME: Wut? See MulTestGPU/MathOpTest below (duplicate?)
 INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
-                        Combine(Values(ADD, MUL),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(1.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(false),
-                                Values(cv::compile_args(CORE_GPU))),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU),
+                                Values(ADD, MUL),
+                                testing::Bool(),
+                                Values(1.0),
+                                Values(false)),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
-                        Combine(Values(MUL),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(1.0, 0.5, 2.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(false),
-                                Values(cv::compile_args(CORE_GPU))),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU),
+                                Values(MUL),
+                                testing::Bool(),
+                                Values(1.0, 0.5, 2.0),
+                                Values(false)),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
-                        Combine(Values(SUB),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values (1.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU),
+                                Values(SUB),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))),
+                                Values (1.0),
+                                testing::Bool()),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(DivTestGPU, MathOpTest,
-                        Combine(Values(DIV),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values (1.0, 0.5, 2.0),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU),
+                                Values(DIV),
                                 testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))),
+                                Values (1.0, 0.5, 2.0),
+                                testing::Bool()),
                         opencv_test::PrintMathOpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest,
@@ -76,8 +79,8 @@ INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -85,8 +88,8 @@ INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -94,16 +97,17 @@ INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-    /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU)));
 
 //TODO: mask test doesn't work
 #if 0
@@ -113,7 +117,7 @@ INSTANTIATE_TEST_CASE_P(MaskTestGPU, MaskTest,
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 #endif
 
 INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest,
@@ -121,42 +125,49 @@ INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_32FC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_32FC1),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
-                        Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
-                                testing::Bool(),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(CV_8U),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))),
+                                Values(CORE_GPU),
+                                Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
+                                testing::Bool()),
                         opencv_test::PrintCmpCoreParams());
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
-                        Combine(Values(AND, OR, XOR),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))),
+                                Values(CORE_GPU),
+                                Values(AND, OR, XOR)),
                         opencv_test::PrintBWCoreParams());
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
@@ -164,49 +175,55 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
- /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ testing::Bool(),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(MinTestGPU, MinTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(MaxTestGPU, MaxTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(AbsToleranceScalar(1e-3).to_compare_f()),//TODO: too relaxed?
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU),
+                                Values(AbsToleranceScalar(1e-3).to_compare_f())));//TODO: too relaxed?
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
@@ -215,17 +232,19 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
                                        cv::Size(128, 128)),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU),
+                                Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f())));
 
 INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
-                        Combine(Values(NORM_INF, NORM_L1, NORM_L2),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_GPU),
                                 Values(AbsToleranceScalar(1e-3).to_compare_f()), //TODO: too relaxed?
-                                Values(cv::compile_args(CORE_GPU))),
+                                Values(NORM_INF, NORM_L1, NORM_L2)),
                         opencv_test::PrintNormCoreParams());
 
 INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest,
@@ -233,25 +252,30 @@ INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU),
+                                Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
+                                    cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
                         Combine(Values(CV_8UC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU),
+                                Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
 
 
 INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest,
@@ -259,123 +283,148 @@ INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC3),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC4),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC1),
+                                Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
-                        Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_GPU),
+                                Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
+                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
                                 Values(cv::Size(64,64),
-                                       cv::Size(30,30)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                       cv::Size(30,30))));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
-                        Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(-1),
+                                Values(false),
+                                Values(CORE_GPU),
+                                Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
+                                Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
                                 Values(0.5, 0.1),
-                                Values(0.5, 0.1),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(0.5, 0.1)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC3),
+                                Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test,
-                        Combine(Values(cv::Size(1280, 720),
+                        Combine(Values(CV_8UC1),
+                                Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC4),
+                                Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
+                                Values(SAME_TYPE),
 /*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(0,1,-1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ Values(false),
+                                Values(CORE_GPU),
+                                Values(0,1,-1)));
 
 INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+/*init output matrices or not*/ Values(false),
+                                Values(CORE_GPU),
+                                Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 
 INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(CV_8UC1),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC1),
+/*init output matrices or not*/ Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest,
                         Combine(Values(CV_8UC3),
-                                Values(CV_8UC3),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-/*init output matrices or not*/ testing::Bool(),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CV_8UC3),
+/*init output matrices or not*/ Values(true),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
-                        Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(CV_8U, CV_16U, CV_16S, CV_32F),
+                        Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(2.5, 1.0, -1.0),
-                                Values(250.0, 0.0, -128.0),
+                                Values(CV_8U, CV_16U, CV_16S, CV_32F),
+                                Values(false),
+                                Values(CORE_GPU),
                                 Values(AbsExact().to_compare_f()),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(2.5, 1.0, -1.0),
+                                Values(250.0, 0.0, -128.0)));
 
 INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(SAME_TYPE),
+                                Values(false),
+                                Values(CORE_GPU)));
 
 //TODO: fix this backend to allow ConcatVertVec ConcatHorVec
 #if 0
@@ -384,13 +433,13 @@ INSTANTIATE_TEST_CASE_P(ConcatVertVecTestGPU, ConcatVertVecTest,
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestGPU, ConcatHorVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
                                 Values(cv::Size(1280, 720),
                                        cv::Size(640, 480),
                                        cv::Size(128, 128)),
-                                Values(cv::compile_args(CORE_GPU))));
+                                Values(CORE_GPU)));
 #endif
 }