diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp
new file mode 100644
index 0000000000000..ca8f185d7a296
--- /dev/null
+++ b/sycl/test/basic_tests/vectors/assign.cpp
@@ -0,0 +1,79 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/sycl.hpp>
+
+using sycl::half;
+using sycl::vec;
+using sw_half_1 = decltype(std::declval<vec<half, 4>>().swizzle<1>());
+using sw_half_2 = decltype(std::declval<vec<half, 4>>().swizzle<1, 2>());
+
+using sw_float_1 = decltype(std::declval<vec<float, 4>>().swizzle<1>());
+using sw_float_2 = decltype(std::declval<vec<float, 4>>().swizzle<1, 2>());
+
+using sw_double_1 = decltype(std::declval<vec<double, 4>>().swizzle<1>());
+using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
+
+// clang-format off
+
+// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
+// macros.
+
+//            IN_PREVIEW_ONLY   condition<>
+//            EXCEPT_IN_PREVIEW condition<>
+
+static_assert(                  std::is_assignable_v<vec<half, 1>, half>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, float>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, double>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<half, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<half, 1>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 1>, sw_double_2>);
+
+static_assert(                  std::is_assignable_v<vec<half, 2>, half>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, float>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, double>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, vec<half, 1>>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, vec<float, 1>>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_double_1>);
+static_assert(                  std::is_assignable_v<vec<half, 2>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<half, 2>, sw_double_2>);
+
+static_assert(                  std::is_assignable_v<vec<float, 1>, half>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, float>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, double>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<half, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<float, 1>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_half_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 1>, sw_double_2>);
+
+static_assert(                  std::is_assignable_v<vec<float, 2>, half>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, float>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, double>);
+#if __SYCL_DEVICE_ONLY__
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+#else
+static_assert(                 !std::is_assignable_v<vec<float, 2>, vec<half, 1>>);
+#endif
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<float, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, vec<double, 1>>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_half_1>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_float_1>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_double_1>);
+static_assert(                 !std::is_assignable_v<vec<float, 2>, sw_half_2>);
+static_assert(                  std::is_assignable_v<vec<float, 2>, sw_float_2>);
+static_assert(                 !std::is_assignable_v<vec<float, 2>, sw_double_2>);
diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
new file mode 100644
index 0000000000000..fb337c0e09e56
--- /dev/null
+++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp
@@ -0,0 +1,134 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/sycl.hpp>
+
+template <class From, class To, class = void>
+struct is_explicitly_convertible_to_impl : std::false_type {};
+
+template <class From, class To>
+struct is_explicitly_convertible_to_impl<
+    From, To, std::void_t<decltype(static_cast<To>(std::declval<From>()))>>
+    : std::true_type {};
+
+template <class From, class To>
+struct is_explicitly_convertible_to
+    : is_explicitly_convertible_to_impl<From, To> {};
+
+template <class From, class To>
+inline constexpr bool is_explicitly_convertible_to_v =
+    is_explicitly_convertible_to<From, To>::value;
+
+using sycl::half;
+using sycl::vec;
+
+void f_half_v1(vec<half, 1>);
+void f_half_v4(vec<half, 4>);
+void f_float_v1(vec<float, 1>);
+void f_float_v4(vec<float, 4>);
+
+using sw_half_1 = decltype(std::declval<vec<half, 4>>().swizzle<1>());
+using sw_half_2 = decltype(std::declval<vec<half, 4>>().swizzle<1, 2>());
+
+using sw_float_1 = decltype(std::declval<vec<float, 4>>().swizzle<1>());
+using sw_float_2 = decltype(std::declval<vec<float, 4>>().swizzle<1, 2>());
+
+using sw_double_1 = decltype(std::declval<vec<double, 4>>().swizzle<1>());
+using sw_double_2 = decltype(std::declval<vec<double, 4>>().swizzle<1, 2>());
+
+// clang-format off
+
+// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY
+// macros.
+
+
+//            IN_PREVIEW_ONLY   condition<>
+//            EXCEPT_IN_PREVIEW condition<>
+
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), half>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), float>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), double>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_half_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_float_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), sw_double_1>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<half, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<float, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_half_v1), vec<double, 1>>);
+
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), half>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), float>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), double>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_half_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_float_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), sw_double_1>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<half, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<float, 1>>);
+static_assert(                  std::is_invocable_v<decltype(f_float_v1), vec<double, 1>>);
+
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), half>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), float>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), double>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_float_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_double_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_half_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_double_2, sw_double_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_half_v4), sw_half_2, sw_double_2>);
+
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), half>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), float>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), double>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_half_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_double_1>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_half_2, sw_half_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_double_2, sw_double_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_float_2>);
+static_assert(                 !std::is_invocable_v<decltype(f_float_v4), sw_float_2, sw_double_2>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<half, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<half, 1>>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<float, 1>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<float, 1>>);
+
+static_assert(                  is_explicitly_convertible_to_v<half,          vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<float,         vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<double,        vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_1,     vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_float_1,    vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_double_1,   vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_half_2,    vec<half, 4>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_float_2,   vec<half, 2>>);
+static_assert(                 !is_explicitly_convertible_to_v<sw_double_2,  vec<half, 2>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+static_assert(                  is_explicitly_convertible_to_v<sw_half_2,     vec<half, 2>>);
+
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  half>);
+#if __SYCL_DEVICE_ONLY__
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(                  is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+#else
+static_assert(                 !is_explicitly_convertible_to_v<vec<half, 1>,  float>);
+static_assert(                 !is_explicitly_convertible_to_v<vec<half, 1>,  double>);
+#endif
+
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  half>);
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  float>);
+static_assert(                  is_explicitly_convertible_to_v<vec<float, 1>,  double>);