Added more strict checks for empty inputs to compare, meanStdDev and RNG::fill

modules/core/src/arithm.cpp

@@ -1233,7 +1233,8 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
     CV_Assert( op == CMP_LT || op == CMP_LE || op == CMP_EQ ||
                op == CMP_NE || op == CMP_GE || op == CMP_GT );
 
-    if(_src1.empty() || _src2.empty())
+    CV_Assert(_src1.empty() == _src2.empty());
+    if (_src1.empty() && _src2.empty())
     {
         _dst.release();
         return;

modules/core/src/copy.cpp

@@ -411,7 +411,8 @@ Mat& Mat::operator = (const Scalar& s)
 {
     CV_INSTRUMENT_REGION()
 
-    if (empty()) return *this;
+    if (this->empty())
+        return *this;
 
     const Mat* arrays[] = { this };
     uchar* dptr;

modules/core/src/mean.cpp

@@ -766,11 +766,13 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
 {
     CV_INSTRUMENT_REGION()
 
+    CV_Assert(!_src.empty());
+    CV_Assert( _mask.empty() || _mask.type() == CV_8UC1 );
+
     CV_OCL_RUN(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                ocl_meanStdDev(_src, _mean, _sdv, _mask))
 
     Mat src = _src.getMat(), mask = _mask.getMat();
-    CV_Assert( mask.empty() || mask.type() == CV_8UC1 );
 
     CV_OVX_RUN(!ovx::skipSmallImages<VX_KERNEL_MEAN_STDDEV>(src.cols, src.rows),
                openvx_meanStdDev(src, _mean, _sdv, mask))

modules/core/src/rand.cpp

@@ -511,8 +511,8 @@ static RandnScaleFunc randnScaleTab[] =
 void RNG::fill( InputOutputArray _mat, int disttype,
                 InputArray _param1arg, InputArray _param2arg, bool saturateRange )
 {
-    if (_mat.empty())
-        return;
+    CV_Assert(!_mat.empty());
+
     Mat mat = _mat.getMat(), _param1 = _param1arg.getMat(), _param2 = _param2arg.getMat();
     int depth = mat.depth(), cn = mat.channels();
     AutoBuffer<double> _parambuf;

modules/core/test/test_arithm.cpp

@@ -1967,11 +1967,9 @@ TEST(Subtract, scalarc4_matc4)
 TEST(Compare, empty)
 {
     cv::Mat temp, dst1, dst2;
-    cv::compare(temp, temp, dst1, cv::CMP_EQ);
-    dst2 = temp > 5;
-
+    EXPECT_NO_THROW(cv::compare(temp, temp, dst1, cv::CMP_EQ));
     EXPECT_TRUE(dst1.empty());
-    EXPECT_TRUE(dst2.empty());
+    EXPECT_THROW(dst2 = temp > 5, cv::Exception);
 }
 
 TEST(Compare, regression_8999)
@@ -1979,9 +1977,7 @@ TEST(Compare, regression_8999)
     Mat_<double> A(4,1); A << 1, 3, 2, 4;
     Mat_<double> B(1,1); B << 2;
     Mat C;
-    ASSERT_ANY_THROW({
-        cv::compare(A, B, C, CMP_LT);
-    });
+    EXPECT_THROW(cv::compare(A, B, C, CMP_LT), cv::Exception);
 }
 
 

modules/core/test/test_concatenation.cpp

@@ -43,106 +43,35 @@
 
 namespace opencv_test { namespace {
 
-class Core_ConcatenationTest : public cvtest::BaseTest
+TEST(Core_Concatenation, empty)
 {
-public:
-    Core_ConcatenationTest(bool horizontal, bool firstEmpty, bool secondEmpty);
-protected:
-    int prepare_test_case( int );
-    void run_func();
-    int validate_test_results( int );
+    const Mat mat0x5(0,5, CV_8U, Scalar::all(1));
+    const Mat mat10x5(10,5, CV_8U, Scalar::all(1));
+    const Mat mat20x5(20,5, CV_8U, Scalar::all(1));
 
-    Mat mat0x5;
-    Mat mat10x5;
-    Mat mat20x5;
-
-    Mat mat5x0;
-    Mat mat5x10;
-    Mat mat5x20;
+    const Mat mat5x0(5,0, CV_8U, Scalar::all(1));
+    const Mat mat5x10(5,10, CV_8U, Scalar::all(1));
+    const Mat mat5x20(5,20, CV_8U, Scalar::all(1));
 
     Mat result;
 
-    bool horizontal;
-    bool firstEmpty;
-    bool secondEmpty;
-
-private:
-    static bool areEqual(const Mat& m1, const Mat& m2);
-
-};
-
-Core_ConcatenationTest::Core_ConcatenationTest(bool horizontal_, bool firstEmpty_, bool secondEmpty_)
-    : horizontal(horizontal_)
-    , firstEmpty(firstEmpty_)
-    , secondEmpty(secondEmpty_)
-{
-    test_case_count = 1;
-
-    mat0x5 = Mat::ones(0,5, CV_8U);
-    mat10x5 = Mat::ones(10,5, CV_8U);
-    mat20x5 = Mat::ones(20,5, CV_8U);
-
-    mat5x0 = Mat::ones(5,0, CV_8U);
-    mat5x10 = Mat::ones(5,10, CV_8U);
-    mat5x20 = Mat::ones(5,20, CV_8U);
-}
-
-int Core_ConcatenationTest::prepare_test_case( int test_case_idx )
-{
-    cvtest::BaseTest::prepare_test_case( test_case_idx );
-    return 1;
-}
-
-void Core_ConcatenationTest::run_func()
-{
-    if (horizontal)
-    {
-        cv::hconcat((firstEmpty ? mat5x0 : mat5x10),
-                    (secondEmpty ? mat5x0 : mat5x10),
-                    result);
-    } else {
-        cv::vconcat((firstEmpty ? mat0x5 : mat10x5),
-                    (secondEmpty ? mat0x5 : mat10x5),
-                    result);
-    }
-}
-
-int Core_ConcatenationTest::validate_test_results( int )
-{
-    Mat expected;
-
-    if (firstEmpty && secondEmpty)
-        expected = (horizontal ? mat5x0 : mat0x5);
-    else if ((firstEmpty && !secondEmpty) || (!firstEmpty && secondEmpty))
-        expected = (horizontal ? mat5x10 : mat10x5);
-    else
-        expected = (horizontal ? mat5x20 : mat20x5);
-
-    if (areEqual(expected, result))
-    {
-        return cvtest::TS::OK;
-    } else
-    {
-        ts->printf( cvtest::TS::LOG, "Concatenation failed");
-        ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
-    }
-
-    return cvtest::TS::OK;
-}
-
-bool Core_ConcatenationTest::areEqual(const Mat &m1, const Mat &m2)
-{
-    return m1.size() == m2.size()
-            && m1.type() == m2.type()
-            && countNonZero(m1 != m2) == 0;
+    cv::hconcat(mat5x0, mat5x0, result);
+    EXPECT_MAT_N_DIFF(result, mat5x0, 0);
+    cv::hconcat(mat5x0, mat5x10, result);
+    EXPECT_MAT_N_DIFF(result, mat5x10, 0);
+    cv::hconcat(mat5x10, mat5x0, result);
+    EXPECT_MAT_N_DIFF(result, mat5x10, 0);
+    cv::hconcat(mat5x10, mat5x10, result);
+    EXPECT_MAT_N_DIFF(result, mat5x20, 0);
+
+    cv::vconcat(mat0x5, mat0x5, result);
+    EXPECT_MAT_N_DIFF(result, mat0x5, 0);
+    cv::vconcat(mat0x5, mat10x5, result);
+    EXPECT_MAT_N_DIFF(result, mat10x5, 0);
+    cv::vconcat(mat10x5, mat0x5, result);
+    EXPECT_MAT_N_DIFF(result, mat10x5, 0);
+    cv::vconcat(mat10x5, mat10x5, result);
+    EXPECT_MAT_N_DIFF(result, mat20x5, 0);
 }
 
-TEST(Core_Concatenation, hconcat_empty_nonempty) { Core_ConcatenationTest test(true, true, false); test.safe_run(); }
-TEST(Core_Concatenation, hconcat_nonempty_empty) { Core_ConcatenationTest test(true, false, true); test.safe_run(); }
-TEST(Core_Concatenation, hconcat_empty_empty) { Core_ConcatenationTest test(true, true, true); test.safe_run(); }
-
-TEST(Core_Concatenation, vconcat_empty_nonempty) { Core_ConcatenationTest test(false, true, false); test.safe_run(); }
-TEST(Core_Concatenation, vconcat_nonempty_empty) { Core_ConcatenationTest test(false, false, true); test.safe_run(); }
-TEST(Core_Concatenation, vconcat_empty_empty) { Core_ConcatenationTest test(false, true, true); test.safe_run(); }
-
 }} // namespace

modules/core/test/test_rand.cpp

@@ -173,7 +173,6 @@ void Core_RandTest::run( int )
                 dsz = slice+1 < maxSlice ? (int)(cvtest::randInt(rng) % (SZ - sz) + 1) : SZ - sz;
                 Mat aslice = arr[k].colRange(sz, sz + dsz);
                 tested_rng.fill(aslice, dist_type, A, B);
-                //printf("%d - %d\n", sz, sz + dsz);
             }
         }