refactored gpu module tests

modules/gpu/test/test_nvidia.cpp

@@ -40,35 +40,198 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "cvconfig.h"
 
-class CV_NVidiaTestsCaller : public cvtest::BaseTest
+#ifdef HAVE_CUDA
+
+enum OutputLevel
 {
-public:
-    CV_NVidiaTestsCaller() {}
-    virtual ~CV_NVidiaTestsCaller() {}
-
-protected:
-    
-	void run( int )
-	{   
-		;
-
-#if defined(HAVE_CUDA)
-		bool main_nvidia(const std::string&);
-
-		// Invoke all NVIDIA Staging tests and obtain the result
-		bool passed = main_nvidia(std::string(ts->get_data_path()) + "haarcascade/");
-
-		if (passed)
-		    ts->set_failed_test_info(cvtest::TS::OK);
-		else
-		    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-
-#else
-		ts->set_failed_test_info(cvtest::TS::SKIPPED);
-#endif
-	}   
+    OutputLevelNone,
+    OutputLevelCompact,
+    OutputLevelFull
 };
 
-TEST(NVidia, multitest) { CV_NVidiaTestsCaller test; test.safe_run(); }
+bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_RectStdDev(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Resize(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Transpose(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Haar_Cascade_Loader(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Haar_Cascade_Application(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Hypotheses_Filtration(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel outputLevel);
+
+struct NVidiaTest : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    static std::string path;
+
+    cv::gpu::DeviceInfo devInfo;
+
+    static void SetUpTestCase() 
+    {
+        path = std::string(cvtest::TS::ptr()->get_data_path()) + "haarcascade/";
+    }
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+std::string NVidiaTest::path;
+
+struct NPPST : NVidiaTest {};
+struct NCV : NVidiaTest {};
+
+OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
+
+TEST_P(NPPST, Integral) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, SquaredIntegral) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, RectStdDev) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, Resize) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, VectorOperations) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, Transpose) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, VectorOperations) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HaarCascadeLoader) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HaarCascadeApplication) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HypothesesFiltration) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, Visualization) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+INSTANTIATE_TEST_CASE_P(NVidia, NPPST, testing::ValuesIn(devices()));
+INSTANTIATE_TEST_CASE_P(NVidia, NCV, testing::ValuesIn(devices()));
+
+#endif // HAVE_CUDA