[SYCL][ESIMD] Add tests on simd increment and decrement operators (intel#827)

* [SYCL][ESIMD] Add tests on simd increment and decrement operators

Author: vasilytric

SYCL/ESIMD/api/functional/operators/operator_decrement_and_increment.hpp

@@ -14,12 +14,19 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+<<<<<<< HEAD
 #define ESIMD_TESTS_DISABLE_DEPRECATED_TEST_DESCRIPTION_FOR_LOGS
+=======
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
 
 #include "../mutator.hpp"
 #include "common.hpp"
 
+<<<<<<< HEAD
 namespace esimd = sycl::ext::intel::esimd;
+=======
+namespace esimd = sycl::ext::intel::experimental::esimd;
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
 namespace esimd_functional = esimd_test::api::functional;
 
 namespace esimd_test::api::functional::operators {
@@ -112,6 +119,41 @@ struct post_increment {
   static constexpr bool is_increment() { return true; }
 };
 
+<<<<<<< HEAD
+=======
+template <typename DataT, int NumElems, typename TestCaseT>
+class IncrementAndDecrementTestDescription : public ITestDescription {
+public:
+  IncrementAndDecrementTestDescription(size_t index, DataT retrieved_val,
+                                       DataT expected_val,
+                                       const std::string &error_details,
+                                       const std::string &data_type)
+      : m_data_type(data_type), m_retrieved_val(retrieved_val),
+        m_expected_val(expected_val), m_index(index),
+        m_error_details(error_details) {}
+
+  std::string to_string() const override {
+    std::string log_msg("Failed for simd<");
+
+    log_msg += m_data_type + ", " + std::to_string(NumElems) + ">";
+    log_msg += ", retrieved: " + std::to_string(m_retrieved_val);
+    log_msg += ", expected: " + std::to_string(m_expected_val);
+    log_msg += ", at index: " + std::to_string(m_index);
+    log_msg += " for " + TestCaseT::get_description() + " operator: ";
+    log_msg += m_error_details;
+
+    return log_msg;
+  }
+
+private:
+  const std::string m_data_type;
+  const DataT m_retrieved_val;
+  const DataT m_expected_val;
+  const size_t m_index;
+  const std::string m_error_details;
+};
+
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
 struct base_test {
   template <typename DataT, int NumElems, typename TestCaseT>
   static std::vector<DataT> generate_input_data() {
@@ -168,7 +210,10 @@ template <typename IsAccuracyTestT, typename DataT, typename SizeT,
           typename TestCaseT>
 class run_test {
   static constexpr int NumElems = SizeT::value;
+<<<<<<< HEAD
   using TestDescriptionT = operators::TestDescription<NumElems, TestCaseT>;
+=======
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
 
 public:
   bool operator()(sycl::queue &queue, const std::string &data_type) {
@@ -198,7 +243,10 @@ class run_test {
            "Reference data size is not equal to the simd vector length.");
 
     bool passed = true;
+<<<<<<< HEAD
     log::trace<TestDescriptionT>(data_type);
+=======
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
 
     shared_allocator<DataT> allocator(queue);
     shared_vector<DataT> source_simd_out(NumElems, allocator);
@@ -226,31 +274,61 @@ class run_test {
           TestCaseT::apply_operator(expected_source_value);
 
       passed &= verify_result(i, expected_source_value, source_simd_out[i],
+<<<<<<< HEAD
                               "argument modification", data_type);
       passed &= verify_result(i, expected_return_value, result_simd_out[i],
                               "return value", data_type);
+=======
+                              "unexpected argument modification", data_type);
+      passed &= verify_result(i, expected_return_value, result_simd_out[i],
+                              "unexpected return value", data_type);
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
     }
 
     return passed;
   }
 
   bool verify_result(size_t i, DataT expected, DataT retrieved,
+<<<<<<< HEAD
                      const std::string &value_description,
+=======
+                     const std::string &simd_type,
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
                      const std::string &data_type) {
     bool passed = true;
     if constexpr (type_traits::is_sycl_floating_point_v<DataT>) {
       if (std::isnan(expected) && !std::isnan(retrieved)) {
         passed = false;
+<<<<<<< HEAD
         log::fail(TestDescriptionT(data_type), "Unexpected ",
                   value_description, "at index ", i, ", retrieved: ", retrieved,
                   ", expected: any NaN value");
+=======
+
+        // TODO: Make ITestDescription architecture more flexible.
+        // We are assuming that the NaN opcode may differ
+        std::string log_msg("Failed for simd<");
+        log_msg += data_type + ", " + std::to_string(NumElems) + ">";
+        log_msg += ". The element at index: " + std::to_string(i) +
+                   ", is not nan, but it should.";
+
+        log::note(log_msg);
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
       }
     }
     if (!are_bitwise_equal(expected, retrieved)) {
       passed = false;
+<<<<<<< HEAD
       log::fail(TestDescriptionT(data_type), "Unexpected ",
                 value_description, "at index ", i, ", retrieved: ", retrieved,
                 ", expected: ", expected);
+=======
+
+      const auto description =
+          IncrementAndDecrementTestDescription<DataT, NumElems, TestCaseT>(
+              i, retrieved, expected, simd_type, data_type);
+      log::fail(description);
+>>>>>>> d6527a558 ([SYCL][ESIMD] Add tests on simd increment and decrement operators (#827))
     }
     return passed;
   }