ENH: update backend tests (#552)

* ENH: update backend tests

Author: samir-nasibli

dpnp/backend/tests/CMakeLists.txt

@@ -44,5 +44,5 @@ enable_testing()
 include_directories(${GTEST_INCLUDE_DIR})
 link_directories(${GTEST_LIB_DIR})
 
-add_executable(dpnpc_tests test_random.cpp)
+add_executable(dpnpc_tests test_main.cpp test_random.cpp)
 target_link_libraries(dpnpc_tests GTest::GTest GTest::Main pthread dpnp_backend_c)

dpnp/backend/tests/test_main.cpp

@@ -0,0 +1,62 @@
+//*****************************************************************************
+// Copyright (c) 2016-2020, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions 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.
+//
+// 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 COPYRIGHT HOLDER 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.
+//*****************************************************************************
+
+#include "gtest/gtest.h"
+
+#include <dpnp_iface.hpp>
+
+// TODO add namespace
+// will added for test_commons
+class DPNPCTestEnvironment : public testing::Environment
+{
+public:
+    void SetUp() override
+    {
+        // TODO update print
+        std::cout << "starting new env" << std::endl << std::endl;
+    }
+    void TearDown() override
+    {
+    }
+};
+
+int RunAllTests(DPNPCTestEnvironment* env)
+{
+    // testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
+    (void)env;
+
+    // It returns 0 if all tests are successful, or 1 otherwise.
+    return RUN_ALL_TESTS();
+}
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+
+    // currently using global queue
+
+    // It returns 0 if all tests are successful, or 1 otherwise.
+    return RUN_ALL_TESTS();
+}

dpnp/backend/tests/test_random.cpp

@@ -26,11 +26,60 @@
 #include <dpnp_iface.hpp>
 #include <dpnp_iface_fptr.hpp>
 
+#include <iostream>
+
 #include <math.h>
 #include <vector>
 
 #include "gtest/gtest.h"
 
+// TODO
+// * data management will be redesigned: allocation as chars (and casting on teste suits)
+// * this class will be generlized
+class RandomTestCase : public ::testing::Test
+{
+public:
+    static void SetUpTestCase()
+    {
+        _get_device_mem();
+    }
+
+    static void TearDownTestCase()
+    {
+        dpnp_memory_free_c(result1);
+        result1 = result2 = nullptr;
+    }
+
+    void SetUp() override
+    {
+        for (size_t i = 0; i < size; ++i)
+        {
+            result1[i] = 1;
+            result2[i] = 0;
+        }
+    }
+
+    void TearDown() override
+    {
+    }
+
+private:
+    static void _get_device_mem()
+    {
+        result1 = (double*)dpnp_memory_alloc_c(size * 2 * sizeof(double));
+        result2 = result1 + size;
+    }
+
+protected:
+    static size_t size;
+    static double* result1;
+    static double* result2;
+};
+
+double* RandomTestCase::result1 = nullptr;
+double* RandomTestCase::result2 = nullptr;
+size_t RandomTestCase::size = 10;
+
 template <typename _DataType>
 bool check_statistics(_DataType* r, double tM, double tD, double tQ, size_t size)
 {
@@ -64,115 +113,75 @@ bool check_statistics(_DataType* r, double tM, double tD, double tQ, size_t size
         return true;
 }
 
-TEST(TestBackendRandomBeta, test_seed)
+TEST_F(RandomTestCase, rng_beta_test_seed)
 {
-    const size_t size = 256;
-    size_t seed = 10;
-    double a = 0.4;
-    double b = 0.5;
-
-    auto QueueOptionsDevices = std::vector<QueueOptions>{QueueOptions::CPU_SELECTOR, QueueOptions::GPU_SELECTOR};
+    const size_t seed = 10;
+    const double a = 0.4;
+    const double b = 0.5;
 
-    for (auto device_selector : QueueOptionsDevices)
-    {
-        dpnp_queue_initialize_c(device_selector);
-        double* result1 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-        double* result2 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_beta_c<double>(result1, a, b, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_beta_c<double>(result1, a, b, size);
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_beta_c<double>(result2, a, b, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_beta_c<double>(result2, a, b, size);
 
-        for (size_t i = 0; i < size; ++i)
-        {
-            EXPECT_NEAR(result1[i], result2[i], 0.004);
-        }
+    for (size_t i = 0; i < size; ++i)
+    {
+        EXPECT_NEAR(result1[i], result2[i], 0.004);
     }
 }
 
-TEST(TestBackendRandomF, test_seed)
+TEST_F(RandomTestCase, rng_f_test_seed)
 {
-    const size_t size = 256;
-    size_t seed = 10;
-    double dfnum = 10.4;
-    double dfden = 12.5;
+    const size_t seed = 10;
+    const double dfnum = 10.4;
+    const double dfden = 12.5;
 
-    auto QueueOptionsDevices = std::vector<QueueOptions>{QueueOptions::CPU_SELECTOR, QueueOptions::GPU_SELECTOR};
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_f_c<double>(result1, dfnum, dfden, size);
 
-    for (auto device_selector : QueueOptionsDevices)
-    {
-        dpnp_queue_initialize_c(device_selector);
-        double* result1 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-        double* result2 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_f_c<double>(result1, dfnum, dfden, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_f_c<double>(result2, dfnum, dfden, size);
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_f_c<double>(result2, dfnum, dfden, size);
-
-        for (size_t i = 0; i < size; ++i)
-        {
-            EXPECT_NEAR(result1[i], result2[i], 0.004);
-        }
+    for (size_t i = 0; i < size; ++i)
+    {
+        EXPECT_NEAR(result1[i], result2[i], 0.004);
     }
 }
 
-TEST(TestBackendRandomNormal, test_seed)
+TEST_F(RandomTestCase, rng_normal_test_seed)
 {
-    const size_t size = 256;
-    size_t seed = 10;
-    double loc = 2.56;
-    double scale = 0.8;
-
-    auto QueueOptionsDevices = std::vector<QueueOptions>{QueueOptions::CPU_SELECTOR, QueueOptions::GPU_SELECTOR};
-
-    for (auto device_selector : QueueOptionsDevices)
-    {
-        dpnp_queue_initialize_c(device_selector);
-        double* result1 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-        double* result2 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
+    const size_t seed = 10;
+    const double loc = 2.56;
+    const double scale = 0.8;
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_normal_c<double>(result1, loc, scale, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_normal_c<double>(result1, loc, scale, size);
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_normal_c<double>(result2, loc, scale, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_normal_c<double>(result2, loc, scale, size);
 
-        for (size_t i = 0; i < size; ++i)
-        {
-            EXPECT_NEAR(result1[i], result2[i], 0.004);
-        }
+    for (size_t i = 0; i < size; ++i)
+    {
+        EXPECT_NEAR(result1[i], result2[i], 0.004);
     }
 }
 
-TEST(TestBackendRandomUniform, test_seed)
+TEST_F(RandomTestCase, rng_uniform_test_seed)
 {
-    const size_t size = 256;
-    size_t seed = 10;
-    long low = 1;
-    long high = 120;
-
-    auto QueueOptionsDevices = std::vector<QueueOptions>{QueueOptions::CPU_SELECTOR, QueueOptions::GPU_SELECTOR};
-
-    for (auto device_selector : QueueOptionsDevices)
-    {
-        dpnp_queue_initialize_c(device_selector);
-        double* result1 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-        double* result2 = (double*)dpnp_memory_alloc_c(size * sizeof(double));
+    const size_t seed = 10;
+    const long low = 1;
+    const long high = 120;
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_uniform_c<double>(result1, low, high, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_uniform_c<double>(result1, low, high, size);
 
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_uniform_c<double>(result2, low, high, size);
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_uniform_c<double>(result2, low, high, size);
 
-        for (size_t i = 0; i < size; ++i)
-        {
-            EXPECT_NEAR(result1[i], result2[i], 0.004);
-        }
+    for (size_t i = 0; i < size; ++i)
+    {
+        EXPECT_NEAR(result1[i], result2[i], 0.004);
     }
 }
 
@@ -189,20 +198,16 @@ TEST(TestBackendRandomUniform, test_statistics)
     double tD = ((b - a) * (b - a)) / 12.0;
     double tQ = ((b - a) * (b - a) * (b - a) * (b - a)) / 80.0;
 
-    auto QueueOptionsDevices = std::vector<QueueOptions>{QueueOptions::CPU_SELECTOR, QueueOptions::GPU_SELECTOR};
-
-    for (auto device_selector : QueueOptionsDevices)
-    {
-        dpnp_queue_initialize_c(device_selector);
-        double* result = (double*)dpnp_memory_alloc_c(size * sizeof(double));
-        dpnp_rng_srand_c(seed);
-        dpnp_rng_uniform_c<double>(result, a, b, size);
-        check_statistics_res = check_statistics<double>(result, tM, tD, tQ, size);
-
-        ASSERT_TRUE(check_statistics_res);
-    }
+    double* result = (double*)dpnp_memory_alloc_c(size * sizeof(double));
+    dpnp_rng_srand_c(seed);
+    dpnp_rng_uniform_c<double>(result, a, b, size);
+    check_statistics_res = check_statistics<double>(result, tM, tD, tQ, size);
+    ASSERT_TRUE(check_statistics_res);
+    dpnp_memory_free_c(result);
 }
 
+// TODO:
+// Generalization for all DPNPFuncName
 TEST(TestBackendRandomSrand, test_func_ptr)
 {
     void* fptr = nullptr;
@@ -216,9 +221,3 @@ TEST(TestBackendRandomSrand, test_func_ptr)
 
     EXPECT_TRUE(fptr != nullptr);
 }
-
-int main(int argc, char** argv)
-{
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}