split each test case

Author: cognex-nalee

modules/cudev/test/test_nd.cu

@@ -4,17 +4,6 @@ using namespace cv;
 using namespace cv::cuda;
 using namespace cvtest;
 
-using ElemTypes = ::testing::Types<
-    Vec<uchar, 1>, Vec<uchar, 2>, Vec<uchar, 3>, Vec<uchar, 4>, // CV_8U
-    Vec<schar, 1>, Vec<schar, 2>, Vec<schar, 3>, Vec<schar, 4>, // CV_8S
-    Vec<ushort, 1>, Vec<ushort, 2>, Vec<ushort, 3>, Vec<ushort, 4>, // CV_16U
-    Vec<short, 1>, Vec<short, 2>, Vec<short, 3>, Vec<short, 4>, // CV_16S
-    Vec<int, 1>, Vec<int, 2>, Vec<int, 3>, Vec<int, 4>, // CV_32S
-    Vec<float, 1>, Vec<float, 2>, Vec<float, 3>, Vec<float, 4>, // CV_32F
-    Vec<double, 1>, Vec<double, 2>, Vec<double, 3>, Vec<double, 4>, //CV_64F
-    Vec<float16_t, 1>, Vec<float16_t, 2>, Vec<float16_t, 3>, Vec<float16_t, 4> // CV_16F
->;
-
 template <typename ElemType>
 class GpuMatNDTest : public ::testing::Test
 {
@@ -24,175 +13,235 @@ public:
     static constexpr int cn = DataType<ElemType>::channels;
     using SizeArray = GpuMatND::SizeArray;
 
-    static void doTest(const SizeArray& size)
+    static MatType RandomMat(const SizeArray& size)
     {
-        const int dims = static_cast<int>(size.size());
+        const auto dims = static_cast<int>(size.size());
 
-        MatType gold(dims, size.data());
-        MatType dst;
+        MatType ret(dims, size.data());
 
-        // init gold with random data
-        for (ElemType& elem : gold)
+        for (ElemType& elem : ret)
             for (int i = 0; i < cn; ++i)
                 elem[i] = static_cast<CnType>(std::rand());
 
-        GpuMatND gmat;
+        return ret;
+    }
 
-        {
-            // simple upload, download test for GpuMatND
+    static std::vector<Range> RandomRange(const SizeArray& size)
+    {
+        const auto dims = static_cast<int>(size.size());
 
-            gmat.upload(gold);
-            gmat.download(dst);
+        std::vector<Range> ret;
 
-            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
-        }
+        const auto margin = std::rand() % 2 + 1; // 1 or 2
 
-        std::vector<Range> ranges;
         for (int s : size)
-            if (s > 2)
-                ranges.emplace_back(1, s-1);
+            if (s > margin * 2)
+                ret.emplace_back(margin, s-margin);
             else
-                ranges.push_back(Range::all());
+                ret.push_back(Range::all());
 
         if (dims == 1)
         {
-            std::vector<Range> ranges_1dfix = ranges;
-            ranges_1dfix.push_back(Range::all());
-
             // Mat expects two ranges even in this case
-            ranges = std::move(ranges_1dfix);
+            ret.push_back(Range::all());
         }
 
-        MatType goldSub = gold(ranges);
+        return ret;
+    }
 
-        {
-            // upload partial mat, download it, and compare
+    static std::vector<Range> RandomRange2D(const SizeArray& size)
+    {
+        const auto dims = static_cast<int>(size.size());
 
-            gmat.upload(goldSub);
-            gmat.download(dst);
+        std::vector<Range> ret = RandomRange(size);
 
-            EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
+        for (int i = 0; i < dims - 2; ++i)
+        {
+            const int start = std::rand() % size[i];
+            ret[i] = Range(start, start + 1);
         }
 
-        {
-            // upload full mat, extract partial mat from it, download it, and compare
+        return ret;
+    }
 
-            gmat.upload(gold);
-            gmat = gmat(ranges);
-            gmat.download(dst);
+    static void doTest1(const SizeArray& size)
+    {
+        const MatType gold = RandomMat(size);
 
-            EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
-        }
+        MatType dst;
+        GpuMatND gmat;
 
-        if (std::is_same<CnType, float16_t>::value)
-        {
-            // The rest of the test uses GpuMat::convertTo
-            // but currently it is not implemented for CV_16F
-            return;
-        }
+        // simple upload, download test for GpuMatND
+        gmat.upload(gold);
+        gmat.download(dst);
+        EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+    }
 
-        {
-            // Test GpuMatND to GpuMat conversion:
+    static void doTest2(const SizeArray& size)
+    {
+        const MatType gold = RandomMat(size);
+        const std::vector<Range> ranges = RandomRange(size);
+        const MatType goldSub = gold(ranges);
+
+        MatType dst;
+        GpuMatND gmat;
+
+        // upload partial mat, download it, and compare
+        gmat.upload(goldSub);
+        gmat.download(dst);
+        EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
 
-            // extract a 2D-plane and set its elements in the extracted region to 1
-            // compare the values of the full mat between Mat and GpuMatND
+        // upload full mat, extract partial mat from it, download it, and compare
+        gmat.upload(gold);
+        gmat = gmat(ranges);
+        gmat.download(dst);
+        EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
+    }
 
-            gmat.upload(gold);
+    static void doTest3(const SizeArray& size)
+    {
+        if (std::is_same<CnType, float16_t>::value) // GpuMat::convertTo is not implemented for CV_16F
+            return;
 
-            for (int i = 0; i < dims - 2; ++i)
-                if (size[i] > 1)
-                    ranges[i] = Range(1, 2);
-                else
-                    ranges[i] = Range::all();
+        const MatType gold = RandomMat(size);
+        const std::vector<Range> ranges = RandomRange2D(size);
 
-            GpuMat plane = gmat(ranges).createGpuMatHeader();
+        MatType dst;
+        GpuMatND gmat;
 
-            EXPECT_TRUE(!plane.refcount); // plane points to externally allocated memory(a part of gmat)
+        // Test GpuMatND to GpuMat conversion:
+        // extract a 2D-plane and set its elements in the extracted region to 1
+        // compare the values of the full mat between Mat and GpuMatND
 
-            const GpuMat dummy = plane.clone();
+        gmat.upload(gold);
+        GpuMat plane = gmat(ranges).createGpuMatHeader();
+        EXPECT_TRUE(!plane.refcount); // plane points to externally allocated memory(a part of gmat)
 
-            EXPECT_TRUE(dummy.refcount); // dummy is clone()-ed from plane, so it manages its memory
+        const GpuMat dummy = plane.clone();
+        EXPECT_TRUE(dummy.refcount); // dummy is clone()-ed from plane, so it manages its memory
 
-            // currently, plane(GpuMat) points to a sub-matrix of gmat(GpuMatND)
-            // in this case, dummy and plane have same size and type,
-            // so plane does not get reallocated inside convertTo,
-            // so this convertTo sets a sub-matrix region of gmat to 1
-            dummy.convertTo(plane, -1, 0, 1);
+        // currently, plane(GpuMat) points to a sub-matrix of gmat(GpuMatND)
+        // in this case, dummy and plane have same size and type,
+        // so plane does not get reallocated inside convertTo,
+        // so this convertTo sets a sub-matrix region of gmat to 1
+        dummy.convertTo(plane, -1, 0, 1);
+        EXPECT_TRUE(!plane.refcount); // plane still points to externally allocated memory(a part of gmat)
 
-            EXPECT_TRUE(!plane.refcount); // plane still points to externally allocated memory(a part of gmat)
+        gmat.download(dst);
 
-            gmat.download(dst);
+        // set a sub-matrix region of gold to 1
+        Mat plane_ = gold(ranges);
+        const Mat dummy_ = plane_.clone();
+        dummy_.convertTo(plane_, -1, 0, 1);
 
-            // set a sub-matrix region of gold to 1
-            Mat plane_ = gold(ranges);
-            const Mat dummy_ = plane_.clone();
-            dummy_.convertTo(plane_, -1, 0, 1);
+        EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+    }
 
-            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
-        }
+    static void doTest4(const SizeArray& size)
+    {
+        if (std::is_same<CnType, float16_t>::value) // GpuMat::convertTo is not implemented for CV_16F
+            return;
 
-        {
-            // Test handling external memory
+        const MatType gold = RandomMat(size);
+        const std::vector<Range> ranges = RandomRange2D(size);
 
-            GpuMatND external(gmat.size, gmat.type(), gmat.getDevicePtr(), {gmat.step.begin(), gmat.step.end() - 1});
+        MatType dst;
+        GpuMatND gmat;
 
-            for (int i = 0; i < dims - 2; ++i)
-                ranges[i] = Range(0, 1);
+        // Test handling external memory
+        gmat.upload(gold);
+        const GpuMatND external(gmat.size, gmat.type(), gmat.getDevicePtr(), {gmat.step.begin(), gmat.step.end() - 1});
 
-            // set a sub-matrix region of external to 2
-            GpuMat plane = external(ranges).createGpuMatHeader();
-            const GpuMat dummy = plane.clone();
-            dummy.convertTo(plane, -1, 0, 2);
-            external.download(dst);
+        // set a sub-matrix region of external to 2
+        GpuMat plane = external(ranges).createGpuMatHeader();
+        const GpuMat dummy = plane.clone();
+        dummy.convertTo(plane, -1, 0, 2);
+        external.download(dst);
 
-            // set a sub-matrix region of gold to 2
-            Mat plane_ = gold(ranges);
-            const Mat dummy_ = plane_.clone();
-            dummy_.convertTo(plane_, -1, 0, 2);
+        // set a sub-matrix region of gold to 2
+        Mat plane_ = gold(ranges);
+        const Mat dummy_ = plane_.clone();
+        dummy_.convertTo(plane_, -1, 0, 2);
 
-            EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
-        }
+        EXPECT_TRUE(std::equal(gold.begin(), gold.end(), dst.begin()));
+    }
 
-        {
-            // Upload a sub-mat, add 1 to a sub-region of the sub-mat, download, and compare
+    static void doTest5(const SizeArray& size)
+    {
+        if (std::is_same<CnType, float16_t>::value) // GpuMat::convertTo is not implemented for CV_16F
+            return;
 
-            gmat.upload(gold(ranges));
+        const MatType gold = RandomMat(size);
+        const std::vector<Range> ranges = RandomRange(size);
+        MatType goldSub = gold(ranges);
 
-            MatType gold_sub = gold(ranges);
+        MatType dst;
+        GpuMatND gmat;
 
-            for (int i = 0; i < dims; ++i)
-                if (gmat.size[i] > 2)
-                    ranges[i] = Range(1, 3);
-                else
-                    ranges[i] = Range::all();
+        // Upload a sub-mat, set a sub-region of the sub-mat to 3, download, and compare
+        gmat.upload(goldSub);
+        const std::vector<Range> rangesInRanges = RandomRange2D(gmat.size);
 
-            GpuMat plane = gmat(ranges).createGpuMatHeader();
-            const GpuMat dummy = plane.clone();
-            dummy.convertTo(plane, -1, 1, 1);
-            gmat.download(dst);
+        GpuMat plane = gmat(rangesInRanges).createGpuMatHeader();
+        const GpuMat dummy = plane.clone();
+        dummy.convertTo(plane, -1, 0, 3);
+        gmat.download(dst);
 
-            Mat plane_ = gold_sub(ranges);
-            const Mat dummy_ = plane_.clone();
-            dummy_.convertTo(plane_, -1, 1, 1);
+        Mat plane_ = goldSub(rangesInRanges);
+        const Mat dummy_ = plane_.clone();
+        dummy_.convertTo(plane_, -1, 0, 3);
 
-            EXPECT_TRUE(std::equal(gold_sub.begin(), gold_sub.end(), dst.begin()));
-        }
+        EXPECT_TRUE(std::equal(goldSub.begin(), goldSub.end(), dst.begin()));
     }
 };
 
+using ElemTypes = ::testing::Types<
+    Vec<uchar, 1>, Vec<uchar, 2>, Vec<uchar, 3>, Vec<uchar, 4>, // CV_8U
+    Vec<schar, 1>, Vec<schar, 2>, Vec<schar, 3>, Vec<schar, 4>, // CV_8S
+    Vec<ushort, 1>, Vec<ushort, 2>, Vec<ushort, 3>, Vec<ushort, 4>, // CV_16U
+    Vec<short, 1>, Vec<short, 2>, Vec<short, 3>, Vec<short, 4>, // CV_16S
+    Vec<int, 1>, Vec<int, 2>, Vec<int, 3>, Vec<int, 4>, // CV_32S
+    Vec<float, 1>, Vec<float, 2>, Vec<float, 3>, Vec<float, 4>, // CV_32F
+    Vec<double, 1>, Vec<double, 2>, Vec<double, 3>, Vec<double, 4>, //CV_64F
+    Vec<float16_t, 1>, Vec<float16_t, 2>, Vec<float16_t, 3>, Vec<float16_t, 4> // CV_16F
+>;
+
+using SizeArray = GpuMatND::SizeArray;
+
+#define DIFFERENT_SIZES_ND std::vector<SizeArray>{ \
+    SizeArray{2, 1}, SizeArray{3, 2, 1}, SizeArray{1, 3, 2, 1}, SizeArray{2, 1, 3, 2, 1}, SizeArray{3, 2, 1, 3, 2, 1}, \
+    SizeArray{1}, SizeArray{1, 1}, SizeArray{1, 1, 1}, SizeArray{1, 1, 1, 1}, \
+    SizeArray{4}, SizeArray{4, 4}, SizeArray{4, 4, 4}, SizeArray{4, 4, 4, 4}, \
+    SizeArray{11}, SizeArray{13, 11}, SizeArray{17, 13, 11}, SizeArray{19, 17, 13, 11}}
+
 TYPED_TEST_CASE(GpuMatNDTest, ElemTypes);
 
 TYPED_TEST(GpuMatNDTest, Test1)
 {
-    using SizeArray = GpuMatND::SizeArray;
+    for (auto& size : DIFFERENT_SIZES_ND)
+        GpuMatNDTest<TypeParam>::doTest1(size);
+}
+
+TYPED_TEST(GpuMatNDTest, Test2)
+{
+    for (auto& size : DIFFERENT_SIZES_ND)
+        GpuMatNDTest<TypeParam>::doTest2(size);
+}
+
+TYPED_TEST(GpuMatNDTest, Test3)
+{
+    for (auto& size : DIFFERENT_SIZES_ND)
+        GpuMatNDTest<TypeParam>::doTest3(size);
+}
 
-    std::vector<SizeArray> sizes = {
-        SizeArray{1}, SizeArray{1, 1}, SizeArray{1, 1, 1}, SizeArray{1, 1, 1, 1},
-        SizeArray{2}, SizeArray{2, 1}, SizeArray{1, 2}, SizeArray{1, 2, 1}, SizeArray{2, 1, 2}, SizeArray{2, 2, 2},
-        SizeArray{64}, SizeArray{64, 64}, SizeArray{16, 64, 64}, SizeArray{4, 16, 64, 64}, SizeArray{2, 4, 16, 64, 64},
-        SizeArray{129}, SizeArray{127, 129}, SizeArray{1, 127, 129}, SizeArray{3, 1, 127, 129}, SizeArray{7, 3, 1, 127, 129},
-    };
+TYPED_TEST(GpuMatNDTest, Test4)
+{
+    for (auto& size : DIFFERENT_SIZES_ND)
+        GpuMatNDTest<TypeParam>::doTest4(size);
+}
 
-    for (auto& size : sizes)
-        GpuMatNDTest<TypeParam>::doTest(size);
+TYPED_TEST(GpuMatNDTest, Test5)
+{
+    for (auto& size : DIFFERENT_SIZES_ND)
+        GpuMatNDTest<TypeParam>::doTest5(size);
 }