Test refactoring: utility and first tests of batches

Author: JohanMabille

test/CMakeLists.txt

@@ -142,7 +142,9 @@ include_directories(${GTEST_INCLUDE_DIRS})
 
 set(XSIMD_TESTS
     main.cpp
-    xsimd_api_test.hpp
+    test_batch.cpp
+    test_utils.hpp
+    #[[    xsimd_api_test.hpp
     xsimd_api_test.cpp
     xsimd_algorithms.cpp
     xsimd_basic_test.hpp
@@ -178,7 +180,7 @@ set(XSIMD_TESTS
     xsimd_tester.hpp
     xsimd_test_utils.hpp
     xsimd_trigonometric_test.hpp
-    xsimd_trigonometric_test.cpp
+    xsimd_trigonometric_test.cpp]]
 )
 
 add_executable(test_xsimd ${XSIMD_TESTS} ${XSIMD_HEADERS})

test/downloadGTest.cmake.in

@@ -15,7 +15,7 @@ project(googletest-download NONE)
 include(ExternalProject)
 ExternalProject_Add(googletest
     GIT_REPOSITORY    https://github.com/google/googletest.git
-    GIT_TAG           release-1.8.1
+    GIT_TAG           release-1.10.0
     SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
     BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
     CONFIGURE_COMMAND ""

test/test_batch.cpp

@@ -0,0 +1,134 @@
+/***************************************************************************
+* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+* Martin Renou                                                             *
+* Copyright (c) QuantStack                                                 *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#include <functional>
+
+#include "test_utils.hpp"
+
+template <class B>
+class batch : public testing::Test
+{
+protected:
+
+    using batch_type = B;
+    using value_type = typename B::value_type;
+    static constexpr size_t size = B::size;
+    using array_type = std::array<value_type, size>;
+
+    array_type lhs;
+    array_type rhs;
+
+    batch()
+    {
+        init_operands();
+    }
+
+    void test_load_store() const
+    {
+        array_type res;
+        batch_type b;
+        b.load_unaligned(lhs.data());
+        b.store_unaligned(res.data());
+        EXPECT_EQ(res, lhs) << print_function_name("load_unaligned / store_unaligned");
+
+        alignas(XSIMD_DEFAULT_ALIGNMENT) array_type arhs(this->rhs);
+        alignas(XSIMD_DEFAULT_ALIGNMENT) array_type ares;
+        b.load_aligned(arhs.data());
+        b.store_aligned(ares.data());
+        EXPECT_EQ(ares, rhs) << print_function_name("load_aligned / store_aligned");
+    }
+
+    void test_constructors() const
+    {
+        array_type tmp;
+        std::fill(tmp.begin(), tmp.end(), value_type(2));
+        batch_type b0(2);
+        EXPECT_EQ(b0, tmp) << print_function_name("batch(value_type)");
+
+        batch_type b1(lhs.data());
+        EXPECT_EQ(b1, lhs) << print_function_name("batch(value_type*)");
+    }
+
+    void test_arithmetic() const
+    {
+        // batch + batch
+        {
+            array_type expected;
+            std::transform(lhs.cbegin(), lhs.cend(), rhs.cbegin(), expected.begin(), std::plus<value_type>());
+            batch_type res = batch_lhs() + batch_rhs();
+            EXPECT_BATCH_EQ(res, expected) << print_function_name("batch + batch");
+        }
+    }
+
+private:
+
+    batch_type batch_lhs() const
+    {
+        return batch_type(lhs.data());
+    }
+
+    batch_type batch_rhs() const
+    {
+        return batch_type(rhs.data());
+    }
+
+    template <class T = value_type>
+    xsimd::enable_integral_t<T, void> init_operands()
+    {
+        for (size_t i = 0; i < size; ++i)
+        {
+            bool negative_lhs = std::is_signed<T>::value && (i % 2 == 1);
+            lhs[i] = value_type(i) * (negative_lhs ? -10 : 10);
+            rhs[i] = value_type(i) + value_type(4);
+        }
+    }
+
+    template <class T = value_type>
+    xsimd::enable_floating_point_t<T, void> init_operands()
+    {
+        for (size_t i = 0; i < size; ++i)
+        {
+            lhs[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
+            rhs[i] = value_type(10.2) / (i + 2) + value_type(0.25);
+        }
+    }
+};
+
+TYPED_TEST_SUITE_P(batch);
+
+TYPED_TEST_P(batch, load_store)
+{
+    this->test_load_store();
+}
+
+TYPED_TEST_P(batch, constructors)
+{
+    this->test_constructors();
+}
+
+TYPED_TEST_P(batch, arithmetic)
+{
+    this->test_arithmetic();
+}
+
+REGISTER_TYPED_TEST_SUITE_P(
+    batch,
+    load_store,
+    constructors,
+    arithmetic
+);
+
+
+#if XSIMD_X86_INSTR_SET >= XSIMD_X86_SSE2_VERSION
+INSTANTIATE_TYPED_TEST_SUITE_P(sse,
+                               batch,
+                               sse_types,
+                               simd_test_names);
+#endif