[ESIMD]Test correctness of type conversion fix (#1170)

* Test correctness of type conversion fix
* Add requirement of aspect-fp64 for the test

Author: fineg74

SYCL/ESIMD/regression/double_conversion.cpp

@@ -0,0 +1,83 @@
+//==--- double_conversion.cpp - DPC++ ESIMD on-device test ---------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This is basic test for testing conversion between double and unsigned int.
+
+// REQUIRES: gpu, aspect-fp64
+// UNSUPPORTED: cuda || hip
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+
+#include <sycl/ext/intel/esimd.hpp>
+#include <sycl/sycl.hpp>
+
+#include <iostream>
+#include <typeinfo>
+
+namespace esimd = sycl::ext::intel::esimd;
+template <typename T> int test(sycl::queue queue, double TestValue) {
+  double input = TestValue;
+  T output = 0;
+  const T expected =
+      static_cast<T>(input); // exact values can be stored in double type, no
+                             // implementation-defined rounding here
+
+  // Call simd conversion constructor
+  // Expectation: data not changed
+  {
+    sycl::range<1> range(1);
+    sycl::buffer<double, 1> buffer_in(&input, range);
+    sycl::buffer<T, 1> buffer_out(&output, range);
+
+    queue
+        .submit([&](sycl::handler &cgh) {
+          const auto in = buffer_in.get_access<sycl::access_mode::read,
+                                               sycl::target::device>(cgh);
+          const auto out =
+              buffer_out.template get_access<sycl::access_mode::write,
+                                             sycl::target::device>(cgh);
+
+          cgh.single_task([=]() SYCL_ESIMD_KERNEL {
+            esimd::simd<double, 1> source;
+            source.copy_from(in, 0);
+
+            esimd::simd<T, 1> destination(source);
+            destination.copy_to(out, 0);
+          });
+        })
+        .wait_and_throw();
+  }
+
+  std::cout << " Expected value: " << expected << "\n";
+  std::cout << " Retrieved value: " << output << "\n";
+
+  if (output == expected) {
+    std::cout << "Test SUCCEED\n";
+    return 0;
+  } else {
+    std::cout << "Test FAILED\n";
+    return 1;
+  }
+}
+
+int main(int, char **) {
+  sycl::queue queue;
+
+  auto dev = queue.get_device();
+  std::cout << "Running on " << dev.get_info<sycl::info::device::name>()
+            << "\n";
+
+  int test_result = 0;
+
+  test_result |= test<unsigned int>(queue, 2147483647);
+  test_result |= test<unsigned int>(queue, 2147483647UL + 1);
+  test_result |= test<unsigned int>(queue, 4294967295);
+
+  test_result |= test<int>(queue, 2147483647);
+
+  return test_result;
+}