ported GPU test to GTest framework

modules/gpu/test/CMakeLists.txt

@@ -5,7 +5,7 @@ include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include"
                     "${CMAKE_CURRENT_SOURCE_DIR}/.."
                     "${CMAKE_CURRENT_BINARY_DIR}")						
 
-set(test_deps opencv_${name} opencv_ts opencv_highgui ${DEPS})
+set(test_deps opencv_${name} opencv_ts opencv_highgui opencv_calib3d ${DEPS})
 foreach(d ${test_deps})
     if(${d} MATCHES "opencv_")
         if(${d} MATCHES "opencv_lapack")

modules/gpu/test/test_features2d.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include <string>
+
+using namespace cv;
+using namespace cv::gpu;
+using namespace std;
+
+const string FEATURES2D_DIR = "features2d";
+const string IMAGE_FILENAME = "aloe.png";
+const string VALID_FILE_NAME = "surf.xml.gz";
+
+class CV_GPU_SURFTest : public cvtest::BaseTest
+{
+public:
+    CV_GPU_SURFTest()
+    {
+    }
+
+protected:
+    bool isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2);
+    void compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints,
+                             const Mat& validDescriptors, const Mat& calcDescriptors);
+
+    void emptyDataTest(SURF_GPU& fdetector);
+    void regressionTest(SURF_GPU& fdetector);
+
+    virtual void run(int);
+};
+
+void CV_GPU_SURFTest::emptyDataTest(SURF_GPU& fdetector)
+{
+    GpuMat image;
+    vector<KeyPoint> keypoints;
+    vector<float> descriptors;
+    try
+    {
+        fdetector(image, GpuMat(), keypoints, descriptors);
+    }
+    catch(...)
+    {
+        ts->printf( cvtest::TS::LOG, "detect() on empty image must not generate exception (1).\n" );
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+    }
+
+    if( !keypoints.empty() )
+    {
+        ts->printf( cvtest::TS::LOG, "detect() on empty image must return empty keypoints vector (1).\n" );
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+        return;
+    }
+
+    if( !descriptors.empty() )
+    {
+        ts->printf( cvtest::TS::LOG, "detect() on empty image must return empty descriptors vector (1).\n" );
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+        return;
+    }
+}
+
+bool CV_GPU_SURFTest::isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2)
+{
+    const float maxPtDif = 1.f;
+    const float maxSizeDif = 1.f;
+    const float maxAngleDif = 2.f;
+    const float maxResponseDif = 0.1f;
+
+    float dist = (float)norm( p1.pt - p2.pt );
+    return (dist < maxPtDif &&
+            fabs(p1.size - p2.size) < maxSizeDif &&
+            abs(p1.angle - p2.angle) < maxAngleDif &&
+            abs(p1.response - p2.response) < maxResponseDif &&
+            p1.octave == p2.octave &&
+            p1.class_id == p2.class_id );
+}
+
+void CV_GPU_SURFTest::compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints, 
+                                          const Mat& validDescriptors, const Mat& calcDescriptors)
+{
+    if (validKeypoints.size() != calcKeypoints.size())
+    {
+        ts->printf(cvtest::TS::LOG, "Keypoints sizes doesn't equal (validCount = %d, calcCount = %d).\n",
+                   validKeypoints.size(), calcKeypoints.size());
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+        return;
+    }
+    if (validDescriptors.size() != calcDescriptors.size())
+    {
+        ts->printf(cvtest::TS::LOG, "Descriptors sizes doesn't equal.\n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+        return;
+    }
+    for (size_t v = 0; v < validKeypoints.size(); v++)
+    {
+        int nearestIdx = -1;
+        float minDist = std::numeric_limits<float>::max();
+
+        for (size_t c = 0; c < calcKeypoints.size(); c++)
+        {
+            float curDist = (float)norm(calcKeypoints[c].pt - validKeypoints[v].pt);
+            if (curDist < minDist)
+            {
+                minDist = curDist;
+                nearestIdx = c;
+            }
+        }
+
+        assert(minDist >= 0);
+        if (!isSimilarKeypoints(validKeypoints[v], calcKeypoints[nearestIdx]))
+        {
+            ts->printf(cvtest::TS::LOG, "Bad keypoints accuracy.\n");
+            ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            return;
+        }
+
+        if (norm(validDescriptors.row(v), calcDescriptors.row(nearestIdx), NORM_L2) > 1.5f)
+        {
+            ts->printf(cvtest::TS::LOG, "Bad descriptors accuracy.\n");
+            ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            return;
+        }
+    }
+}
+
+void CV_GPU_SURFTest::regressionTest(SURF_GPU& fdetector)
+{
+    string imgFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + IMAGE_FILENAME;
+    string resFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + VALID_FILE_NAME;
+
+    // Read the test image.
+    GpuMat image(imread(imgFilename, 0));
+    if (image.empty())
+    {
+        ts->printf( cvtest::TS::LOG, "Image %s can not be read.\n", imgFilename.c_str() );
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+
+    FileStorage fs(resFilename, FileStorage::READ);
+
+    // Compute keypoints.
+    GpuMat mask(image.size(), CV_8UC1, Scalar::all(1));
+    mask(Range(0, image.rows / 2), Range(0, image.cols / 2)).setTo(Scalar::all(0));
+    vector<KeyPoint> calcKeypoints;
+    GpuMat calcDespcriptors;
+    fdetector(image, mask, calcKeypoints, calcDespcriptors);
+
+    if (fs.isOpened()) // Compare computed and valid keypoints.
+    {
+        // Read validation keypoints set.
+        vector<KeyPoint> validKeypoints;
+        Mat validDespcriptors;
+        read(fs["keypoints"], validKeypoints);
+        read(fs["descriptors"], validDespcriptors);
+        if (validKeypoints.empty() || validDespcriptors.empty())
+        {
+            ts->printf(cvtest::TS::LOG, "Validation file can not be read.\n");
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+
+        compareKeypointSets(validKeypoints, calcKeypoints, validDespcriptors, calcDespcriptors);
+    }
+    else // Write detector parameters and computed keypoints as validation data.
+    {
+        fs.open(resFilename, FileStorage::WRITE);
+        if (!fs.isOpened())
+        {
+            ts->printf(cvtest::TS::LOG, "File %s can not be opened to write.\n", resFilename.c_str());
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+        else
+        {
+            write(fs, "keypoints", calcKeypoints);
+            write(fs, "descriptors", (Mat)calcDespcriptors);
+        }
+    }
+}
+
+void CV_GPU_SURFTest::run( int /*start_from*/ )
+{
+    SURF_GPU fdetector;
+
+    emptyDataTest(fdetector);
+    regressionTest(fdetector);
+}
+
+TEST(SURF, empty_data_and_regression) { CV_GPU_SURFTest test; test.safe_run(); }

modules/gpu/test/test_main.cpp

@@ -5,4 +5,4 @@ CV_TEST_MAIN("gpu")
 // Run test with --gtest_catch_exceptions flag to avoid runtime errors in 
 // the case when there is no GPU
 
-// TODO Add other tests from tests/gpu folder
+// TODO Add NVIDIA tests

modules/gpu/test/test_meanshift.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include <iostream>
+#include <string>
+
+using namespace cv;
+using namespace cv::gpu;
+
+
+struct CV_GpuMeanShiftTest : public cvtest::BaseTest
+{
+    CV_GpuMeanShiftTest() {}
+
+    void run(int)
+    {
+        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
+        if (!cc12_ok)
+        {
+            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+            return;
+        }
+
+        int spatialRad = 30;
+        int colorRad = 30;
+
+        cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png");
+        cv::Mat img_template;       
+        
+        if (cv::gpu::TargetArchs::builtWith(cv::gpu::FEATURE_SET_COMPUTE_20) &&
+            cv::gpu::DeviceInfo().supports(cv::gpu::FEATURE_SET_COMPUTE_20))
+            img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result.png");
+        else
+            img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result_CC1X.png");
+
+        if (img.empty() || img_template.empty())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+            return;
+        }
+
+        cv::Mat rgba;
+        cvtColor(img, rgba, CV_BGR2BGRA);
+
+
+        cv::gpu::GpuMat res;
+        cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), res, spatialRad, colorRad );
+
+        if (res.type() != CV_8UC4)
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+            return;
+        }
+
+        cv::Mat result;
+        res.download(result);
+
+        uchar maxDiff = 0;
+        for (int j = 0; j < result.rows; ++j)
+        {
+            const uchar* res_line = result.ptr<uchar>(j);
+            const uchar* ref_line = img_template.ptr<uchar>(j);
+
+            for (int i = 0; i < result.cols; ++i)
+            {
+                for (int k = 0; k < 3; ++k)
+                {
+                    const uchar& ch1 = res_line[result.channels()*i + k];
+                    const uchar& ch2 = ref_line[img_template.channels()*i + k];
+                    uchar diff = static_cast<uchar>(abs(ch1 - ch2));
+                    if (maxDiff < diff)
+                        maxDiff = diff;
+                }
+            }
+        }
+        if (maxDiff > 0)
+        {
+            ts->printf(cvtest::TS::LOG, "\nMeanShift maxDiff = %d\n", maxDiff);
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+            return;
+        }
+
+        ts->set_failed_test_info(cvtest::TS::OK);
+    }
+
+};
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////// tests registration  /////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+CV_GpuMeanShiftTest CV_GpuMeanShift_test;
+
+struct CV_GpuMeanShiftProcTest : public cvtest::BaseTest
+{
+    CV_GpuMeanShiftProcTest() {}
+
+    void run(int)
+    {
+        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
+        if (!cc12_ok)
+        {
+            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+            return;
+        }
+
+        int spatialRad = 30;
+        int colorRad = 30;
+
+        cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png");
+
+        if (img.empty())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+            return;
+        }
+
+        cv::Mat rgba;
+        cvtColor(img, rgba, CV_BGR2BGRA);
+
+        cv::gpu::GpuMat h_rmap_filtered;
+        cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), h_rmap_filtered, spatialRad, colorRad );
+
+        cv::gpu::GpuMat d_rmap;
+        cv::gpu::GpuMat d_spmap;
+        cv::gpu::meanShiftProc( cv::gpu::GpuMat(rgba), d_rmap, d_spmap, spatialRad, colorRad );
+
+        if (d_rmap.type() != CV_8UC4)
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+            return;
+        }
+
+        cv::Mat rmap_filtered;
+        h_rmap_filtered.download(rmap_filtered);
+
+        cv::Mat rmap;
+        d_rmap.download(rmap);
+
+        uchar maxDiff = 0;
+        for (int j = 0; j < rmap_filtered.rows; ++j)
+        {
+            const uchar* res_line = rmap_filtered.ptr<uchar>(j);
+            const uchar* ref_line = rmap.ptr<uchar>(j);
+
+            for (int i = 0; i < rmap_filtered.cols; ++i)
+            {
+                for (int k = 0; k < 3; ++k)
+                {
+                    const uchar& ch1 = res_line[rmap_filtered.channels()*i + k];
+                    const uchar& ch2 = ref_line[rmap.channels()*i + k];
+                    uchar diff = static_cast<uchar>(abs(ch1 - ch2));
+                    if (maxDiff < diff)
+                        maxDiff = diff;
+                }
+            }
+        }
+        if (maxDiff > 0)
+        {
+            ts->printf(cvtest::TS::LOG, "\nMeanShiftProc maxDiff = %d\n", maxDiff);
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+            return;
+        }
+
+        cv::Mat spmap;
+        d_spmap.download(spmap);
+
+        cv::Mat spmap_template;
+        cv::FileStorage fs;
+
+        if (cv::gpu::TargetArchs::builtWith(cv::gpu::FEATURE_SET_COMPUTE_20) &&
+            cv::gpu::DeviceInfo().supports(cv::gpu::FEATURE_SET_COMPUTE_20))
+            fs.open(std::string(ts->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+        else
+            fs.open(std::string(ts->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+        fs["spmap"] >> spmap_template;
+
+        for (int y = 0; y < spmap.rows; ++y) {
+            for (int x = 0; x < spmap.cols; ++x) {
+                cv::Point_<short> expected = spmap_template.at<cv::Point_<short> >(y, x);
+                cv::Point_<short> actual = spmap.at<cv::Point_<short> >(y, x);
+                int diff = (expected - actual).dot(expected - actual);
+                if (actual != expected) {
+                    ts->printf(cvtest::TS::LOG, "\nMeanShiftProc SpMap is bad, diff=%d\n", diff);
+                    ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+                    return;
+                }
+            }
+        }
+
+        ts->set_failed_test_info(cvtest::TS::OK);
+    }
+
+};
+
+TEST(meanShiftProc, accuracy) { CV_GpuMeanShiftProcTest test; test.safe_run(); }

modules/gpu/test/test_mssegmentation.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <iostream>
+#include <string>
+#include <iosfwd>
+#include "test_precomp.hpp"
+using namespace cv;
+using namespace cv::gpu;
+using namespace std;
+
+struct CV_GpuMeanShiftSegmentationTest : public cvtest::BaseTest {
+    CV_GpuMeanShiftSegmentationTest() {}
+
+    void run(int) 
+    {
+        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
+        if (!cc12_ok)
+        {
+            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+            return;
+        }
+
+        Mat img_rgb = imread(string(ts->get_data_path()) + "meanshift/cones.png");
+        if (img_rgb.empty())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+            return;
+        }
+
+        Mat img;
+        cvtColor(img_rgb, img, CV_BGR2BGRA);
+
+
+        for (int minsize = 0; minsize < 2000; minsize = (minsize + 1) * 4)
+        {
+            stringstream path;
+            path << ts->get_data_path() << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+            if (TargetArchs::builtWith(FEATURE_SET_COMPUTE_20) && DeviceInfo().supports(FEATURE_SET_COMPUTE_20))
+                path << ".png";
+            else
+                path << "_CC1X.png";
+
+            Mat dst;
+            meanShiftSegmentation((GpuMat)img, dst, 10, 10, minsize);
+            Mat dst_rgb;
+            cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+
+            //imwrite(path.str(), dst_rgb);
+            Mat dst_ref = imread(path.str());
+            if (dst_ref.empty())
+            {
+                ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+                return;
+            }
+            if (CheckSimilarity(dst_rgb, dst_ref, 1e-3f) != cvtest::TS::OK)
+            {
+                ts->printf(cvtest::TS::LOG, "\ndiffers from image *minsize%d.png\n", minsize);
+                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            }
+        }
+
+        ts->set_failed_test_info(cvtest::TS::OK);
+    }    
+
+    int CheckSimilarity(const Mat& m1, const Mat& m2, float max_err)
+    {
+        Mat diff;
+        cv::matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
+
+        float err = abs(diff.at<float>(0, 0) - 1.f);
+
+        if (err > max_err)
+            return cvtest::TS::FAIL_INVALID_OUTPUT;
+
+        return cvtest::TS::OK;
+    }
+
+
+};
+
+
+TEST(meanShiftSegmentation, regression) { CV_GpuMeanShiftSegmentationTest test; test.safe_run(); }

modules/gpu/test/test_operator_async_call.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+struct CV_AsyncGpuMatTest : public cvtest::BaseTest
+{
+    CV_AsyncGpuMatTest() {}
+
+    void run(int)
+    {
+        CudaMem src(Mat::zeros(100, 100, CV_8UC1));
+
+        GpuMat gpusrc;
+        GpuMat gpudst0, gpudst1(100, 100, CV_8UC1);
+
+        CudaMem cpudst0;
+        CudaMem cpudst1;
+
+        Stream stream0, stream1;
+
+        stream0.enqueueUpload(src, gpusrc);
+        bitwise_not(gpusrc, gpudst0, GpuMat(), stream0);
+        stream0.enqueueDownload(gpudst0, cpudst0);
+
+        stream1.enqueueMemSet(gpudst1, Scalar::all(128));
+        stream1.enqueueDownload(gpudst1, cpudst1);
+
+        stream0.waitForCompletion();
+        stream1.waitForCompletion();
+
+        Mat cpu_gold0(100, 100, CV_8UC1, Scalar::all(255));
+        Mat cpu_gold1(100, 100, CV_8UC1, Scalar::all(128));
+
+        if (norm(cpudst0, cpu_gold0, NORM_INF) > 0 || norm(cpudst1, cpu_gold1, NORM_INF) > 0)
+            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+        else
+            ts->set_failed_test_info(cvtest::TS::OK);
+    }
+};
+
+TEST(GpuMat, async) { CV_AsyncGpuMatTest test; test.safe_run(); }

modules/gpu/test/test_operator_convert_to.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#include <fstream>
+#include <iterator>
+#include <numeric>
+
+using namespace cv;
+using namespace std;
+using namespace gpu;
+
+class CV_GpuMatOpConvertToTest : public cvtest::BaseTest
+{
+    public:
+        CV_GpuMatOpConvertToTest() {}
+        ~CV_GpuMatOpConvertToTest() {}
+
+    protected:
+        void run(int);
+};
+
+void CV_GpuMatOpConvertToTest::run(int /* start_from */)
+{
+    const Size img_size(67, 35);
+
+    const char* types_str[] = {"CV_8U", "CV_8S", "CV_16U", "CV_16S", "CV_32S", "CV_32F", "CV_64F"};
+
+    bool passed = true;
+    int lastType = CV_32F;
+
+    if (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE))
+        lastType = CV_64F;
+
+    for (int i = 0; i <= lastType && passed; ++i)
+    {
+        for (int j = 0; j <= lastType && passed; ++j)
+        {
+            for (int c = 1; c < 5 && passed; ++c)
+            {
+                const int src_type = CV_MAKETYPE(i, c);
+                const int dst_type = j;
+
+                cv::RNG& rng = ts->get_rng();
+
+                Mat cpumatsrc(img_size, src_type);
+                rng.fill(cpumatsrc, RNG::UNIFORM, Scalar::all(0), Scalar::all(300));
+
+                GpuMat gpumatsrc(cpumatsrc);
+                Mat cpumatdst;
+                GpuMat gpumatdst;
+
+                cpumatsrc.convertTo(cpumatdst, dst_type, 0.5, 3.0);
+                gpumatsrc.convertTo(gpumatdst, dst_type, 0.5, 3.0);
+
+                double r = norm(cpumatdst, gpumatdst, NORM_INF);
+                if (r > 1)
+                {
+                    ts->printf(cvtest::TS::LOG,
+                               "\nFAILED: SRC_TYPE=%sC%d DST_TYPE=%s NORM = %f\n",
+                               types_str[i], c, types_str[j], r);
+                    passed = false;
+                }
+            }
+        }
+    }
+
+    ts->set_failed_test_info(passed ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC);
+}
+
+TEST(GpuMat_convertTo, accuracy) { CV_GpuMatOpConvertToTest test; test.safe_run(); }

modules/gpu/test/test_precomp.hpp

 #ifndef __OPENCV_TEST_PRECOMP_HPP__
 #define __OPENCV_TEST_PRECOMP_HPP__
 
+#include <limits>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
 #include "opencv2/ts/ts.hpp"
 #include "opencv2/gpu/gpu.hpp"
-#include "opencv2/highgui/highgui.hpp"
 
 #endif

modules/gpu/test/test_stereo_bp.cpp

@@ -79,4 +79,4 @@ struct CV_GpuStereoBPTest : public cvtest::BaseTest
     }
 };
 
-TEST(StereoBP, StereoBP) { CV_GpuStereoBPTest test; test.safe_run(); }
\ No newline at end of file
+TEST(StereoBP, regression) { CV_GpuStereoBPTest test; test.safe_run(); }