diff --git a/SYCL/Complex/sycl_complex_helper.hpp b/SYCL/Complex/sycl_complex_helper.hpp
new file mode 100644
index 0000000000..6c8ec7ff9f
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_helper.hpp
@@ -0,0 +1,203 @@
+#include <cmath>
+#include <iomanip>
+
+#define SYCL_EXT_ONEAPI_COMPLEX
+#include <sycl/ext/oneapi/experimental/sycl_complex.hpp>
+#include <sycl/sycl.hpp>
+
+using namespace sycl::ext::oneapi;
+
+#define SYCL_CPLX_TOL_ULP 5
+
+#define PI 3.14159265358979323846
+
+constexpr double INFINITYd(std::numeric_limits<double>::infinity());
+constexpr double NANd(std::numeric_limits<double>::quiet_NaN());
+
+template <typename T = double> struct cmplx {
+  cmplx(T real, T imag) : re(real), im(imag) {}
+
+  template <typename X> cmplx(cmplx<X> c) {
+    re = c.re;
+    im = c.im;
+  }
+
+  T re;
+  T im;
+};
+
+// Helpers for displaying results
+
+template <typename T> const char *get_typename() { return "Unknown type"; }
+template <> const char *get_typename<double>() { return "double"; }
+template <> const char *get_typename<float>() { return "float"; }
+template <> const char *get_typename<sycl::half>() { return "sycl::half"; }
+
+// Helper to test each complex specilization
+template <template <typename> typename action, typename... argsT>
+bool test_valid_types(sycl::queue &Q, argsT... args) {
+  bool test_passes = true;
+
+  if (Q.get_device().has(sycl::aspect::fp64)) {
+    action<double> test;
+    test_passes &= test(Q, args...);
+  }
+
+  {
+    action<float> test;
+    test_passes &= test(Q, args...);
+  }
+
+  if (Q.get_device().has(sycl::aspect::fp16)) {
+    action<sycl::half> test;
+    test_passes &= test(Q, args...);
+  }
+
+  return test_passes;
+}
+
+// Overload for host only tests
+template <template <typename> typename action, typename... argsT>
+bool test_valid_types(argsT... args) {
+  bool test_passes = true;
+
+  {
+    action<double> test;
+    test_passes &= test(args...);
+  }
+
+  {
+    action<float> test;
+    test_passes &= test(args...);
+  }
+
+  {
+    action<sycl::half> test;
+    test_passes &= test(args...);
+  }
+
+  return test_passes;
+}
+
+// Helpers for comparison
+
+template <typename T> bool almost_equal_scalar(T x, T y, int ulp) {
+  if (std::isnan(x) && std::isnan(y))
+    return true;
+
+  if (std::isinf(x) && std::isinf(y))
+    return true;
+
+  return std::abs(x - y) <=
+             std::numeric_limits<T>::epsilon() * std::abs(x + y) * ulp ||
+         std::abs(x - y) < std::numeric_limits<T>::min();
+}
+
+template <typename T> T complex_magnitude(std::complex<T> a) {
+  return std::sqrt(a.real() * a.real() + a.imag() * a.imag());
+}
+
+template <typename T> T complex_magnitude(experimental::complex<T> a) {
+  return std::sqrt(a.real() * a.real() + a.imag() * a.imag());
+}
+
+template <typename T, typename U> inline bool is_nan_or_inf(T x, U y) {
+  return (std::isnan(x.real()) && std::isnan(y.real())) ||
+         (std::isnan(x.imag()) && std::isnan(y.imag())) ||
+         (std::isinf(x.real()) && std::isinf(y.real())) ||
+         (std::isinf(x.imag()) && std::isinf(y.imag()));
+}
+
+template <typename T>
+bool almost_equal_cplx(experimental::complex<T> x, experimental::complex<T> y,
+                       int ulp) {
+  auto diff = complex_magnitude(x - y);
+  return diff <= std::numeric_limits<T>::epsilon() * std::abs(x + y) * ulp ||
+         diff < std::numeric_limits<T>::min() || is_nan_or_inf(x, y);
+}
+
+template <typename T>
+bool almost_equal_cplx(experimental::complex<T> x, std::complex<T> y, int ulp) {
+  auto stdx = std::complex{x.real(), x.imag()};
+  auto diff = complex_magnitude(stdx - y);
+  return diff <= std::numeric_limits<T>::epsilon() * std::abs(stdx + y) * ulp ||
+         diff < std::numeric_limits<T>::min() || is_nan_or_inf(x, y);
+}
+
+template <typename T>
+bool almost_equal_cplx(std::complex<T> x, experimental::complex<T> y, int ulp) {
+  auto stdy = std::complex{y.real(), y.imag()};
+  auto diff = complex_magnitude(x - stdy);
+  return diff <= std::numeric_limits<T>::epsilon() * std::abs(x + stdy) * ulp ||
+         diff < std::numeric_limits<T>::min() || is_nan_or_inf(x, y);
+}
+
+template <typename T>
+bool almost_equal_cplx(std::complex<T> x, std::complex<T> y, int ulp) {
+  auto diff = complex_magnitude(x - y);
+  return diff <= std::numeric_limits<T>::epsilon() * std::abs(x + y) * ulp ||
+         diff < std::numeric_limits<T>::min() || is_nan_or_inf(x, y);
+}
+
+// Helpers for testing half
+
+std::complex<float> sycl_half_to_float(experimental::complex<sycl::half> c) {
+  auto c_sycl_float = static_cast<experimental::complex<float>>(c);
+  return static_cast<std::complex<float>>(c_sycl_float);
+}
+
+std::complex<sycl::half> sycl_float_to_half(std::complex<float> c) {
+  auto c_sycl_half = static_cast<experimental::complex<sycl::half>>(c);
+  return static_cast<std::complex<sycl::half>>(c_sycl_half);
+}
+
+std::complex<float> trunc_float(std::complex<float> c) {
+  auto c_sycl_half = static_cast<experimental::complex<sycl::half>>(c);
+  return sycl_half_to_float(c_sycl_half);
+}
+
+// Helper for initializing std::complex values for tests only needed because
+// sycl::half cases are emulated with float for std::complex class
+
+template <typename T_in> auto constexpr init_std_complex(T_in re, T_in im) {
+  return std::complex<T_in>(re, im);
+}
+
+template <> auto constexpr init_std_complex(sycl::half re, sycl::half im) {
+  return trunc_float(std::complex<float>(re, im));
+}
+
+template <typename T_in> auto constexpr init_deci(T_in re) { return re; }
+
+template <> auto constexpr init_deci(sycl::half re) {
+  return static_cast<float>(re);
+}
+
+// Helper for comparing SyclCPLX and standard c++ results
+
+template <typename T>
+bool check_results(experimental::complex<T> output, std::complex<T> reference,
+                   bool is_device) {
+  if (!almost_equal_cplx(output, reference, SYCL_CPLX_TOL_ULP)) {
+    std::cerr << std::setprecision(std::numeric_limits<T>::max_digits10)
+              << "Test failed with complex_type: " << get_typename<T>()
+              << " Computed on " << (is_device ? "device" : "host")
+              << " Output: " << output << " Reference: " << reference
+              << std::endl;
+    return false;
+  }
+  return true;
+}
+
+template <typename T>
+bool check_results(T output, T reference, bool is_device) {
+  if (!almost_equal_scalar(output, reference, SYCL_CPLX_TOL_ULP)) {
+    std::cerr << std::setprecision(std::numeric_limits<T>::max_digits10)
+              << "Test failed with complex_type: " << get_typename<T>()
+              << " Computed on " << (is_device ? "device" : "host")
+              << " Output: " << output << " Reference: " << reference
+              << std::endl;
+    return false;
+  }
+  return true;
+}
diff --git a/SYCL/Complex/sycl_complex_math_test.cpp b/SYCL/Complex/sycl_complex_math_test.cpp
new file mode 100644
index 0000000000..35979d5f56
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_math_test.cpp
@@ -0,0 +1,253 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %HOST_RUN_PLACEHOLDER %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_helper.hpp"
+#include "sycl_complex_math_test_cases.hpp"
+
+// Macro for testing complex in, complex out functions
+
+#define TEST_MATH_OP_TYPE(math_func)                                           \
+  template <typename T> struct test_##math_func {                              \
+    bool operator()(sycl::queue &Q, cmplx<T> init,                             \
+                    cmplx<T> ref = cmplx<T>(0, 0), bool use_ref = false) {     \
+      bool pass = true;                                                        \
+                                                                               \
+      auto std_in = init_std_complex(init.re, init.im);                        \
+      experimental::complex<T> cplx_input{init.re, init.im};                   \
+                                                                               \
+      auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);    \
+                                                                               \
+      /*Get std::complex output*/                                              \
+      std::complex<T> std_out{ref.re, ref.im};                                 \
+      if (!use_ref)                                                            \
+        std_out = std::math_func(std_in);                                      \
+                                                                               \
+      /*Check cplx::complex output from device*/                               \
+      Q.single_task([=]() {                                                    \
+         cplx_out[0] = experimental::math_func<T>(cplx_input);                 \
+       }).wait();                                                              \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);         \
+                                                                               \
+      /*Check cplx::complex output from host*/                                 \
+      cplx_out[0] = experimental::math_func<T>(cplx_input);                    \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);        \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_OP_TYPE(acos)
+TEST_MATH_OP_TYPE(asin)
+TEST_MATH_OP_TYPE(atan)
+TEST_MATH_OP_TYPE(acosh)
+TEST_MATH_OP_TYPE(asinh)
+TEST_MATH_OP_TYPE(atanh)
+TEST_MATH_OP_TYPE(conj)
+TEST_MATH_OP_TYPE(cos)
+TEST_MATH_OP_TYPE(cosh)
+TEST_MATH_OP_TYPE(exp)
+TEST_MATH_OP_TYPE(log)
+TEST_MATH_OP_TYPE(log10)
+TEST_MATH_OP_TYPE(proj)
+TEST_MATH_OP_TYPE(sin)
+TEST_MATH_OP_TYPE(sinh)
+TEST_MATH_OP_TYPE(sqrt)
+TEST_MATH_OP_TYPE(tan)
+TEST_MATH_OP_TYPE(tanh)
+
+#undef TEST_MATH_OP_TYPE
+
+// Macro for testing complex in, decimal out functions
+
+#define TEST_MATH_OP_TYPE(math_func)                                           \
+  template <typename T> struct test_##math_func {                              \
+    bool operator()(sycl::queue &Q, cmplx<T> init,                             \
+                    cmplx<T> ref = cmplx<T>(0, 0), bool use_ref = false) {     \
+      bool pass = true;                                                        \
+                                                                               \
+      auto std_in = init_std_complex(init.re, init.im);                        \
+      experimental::complex<T> cplx_input{init.re, init.im};                   \
+                                                                               \
+      auto *cplx_out = sycl::malloc_shared<T>(1, Q);                           \
+                                                                               \
+      /*Get std::complex output*/                                              \
+      T std_out = ref.re;                                                      \
+      if (!use_ref)                                                            \
+        std_out = std::math_func(std_in);                                      \
+                                                                               \
+      /*Check cplx::complex output from device*/                               \
+      Q.single_task([=]() {                                                    \
+         cplx_out[0] = experimental::math_func<T>(cplx_input);                 \
+       }).wait();                                                              \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);         \
+                                                                               \
+      /*Check cplx::complex output from host*/                                 \
+      cplx_out[0] = experimental::math_func<T>(cplx_input);                    \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);        \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_OP_TYPE(abs)
+TEST_MATH_OP_TYPE(arg)
+TEST_MATH_OP_TYPE(norm)
+
+#undef TEST_MATH_OP_TYPE
+
+// Test for polar function
+// The real component is treated as radius rho, and the imaginary component as
+// angular value theta
+template <typename T> struct test_polar {
+  bool operator()(sycl::queue &Q, cmplx<T> init, cmplx<T> ref = cmplx<T>(0, 0),
+                  bool use_ref = false) {
+    bool pass = true;
+
+    auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);
+
+    /*Get std::complex output*/
+    std::complex<T> std_out{ref.re, ref.im};
+    if (!use_ref)
+      std_out = std::polar(init.re, init.im);
+
+    /*Check cplx::complex output from device*/
+    Q.single_task([=]() {
+       cplx_out[0] = experimental::polar<T>(init.re, init.im);
+     }).wait();
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);
+
+    /*Check cplx::complex output from host*/
+    cplx_out[0] = experimental::polar<T>(init.re, init.im);
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  {
+    test_cases<test_acos> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_asin> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_atan> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_acosh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_asinh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_atanh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_conj> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_cos> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_cosh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_log> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_log10> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_proj> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_sin> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_sinh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_sqrt> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_tan> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_tanh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_abs> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_arg> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_norm> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_polar> test;
+    test_passes &= test(Q);
+  }
+
+  return !test_passes;
+}
diff --git a/SYCL/Complex/sycl_complex_math_test_cases.hpp b/SYCL/Complex/sycl_complex_math_test_cases.hpp
new file mode 100644
index 0000000000..3e5eabda18
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_math_test_cases.hpp
@@ -0,0 +1,260 @@
+using std::pair;
+using std::tuple;
+using std::vector;
+
+// Forward decleration of tests
+
+template <typename T> class test_acos;
+template <typename T> class test_asin;
+template <typename T> class test_atan;
+template <typename T> class test_acosh;
+template <typename T> class test_asinh;
+template <typename T> class test_atanh;
+template <typename T> class test_conj;
+template <typename T> class test_cos;
+template <typename T> class test_cosh;
+template <typename T> class test_exp;
+template <typename T> class test_log;
+template <typename T> class test_log10;
+template <typename T> class test_proj;
+template <typename T> class test_sin;
+template <typename T> class test_sinh;
+template <typename T> class test_sqrt;
+template <typename T> class test_tan;
+template <typename T> class test_tanh;
+
+template <typename T> class test_abs;
+template <typename T> class test_arg;
+template <typename T> class test_norm;
+
+template <typename T> class test_polar;
+
+// Stores test cases for each math function used in sycl_complex_math_test.cpp
+// Values are stored in the highest precision type, in this case that is double
+
+template <template <typename> typename test_struct> struct test_cases {
+  // Default test cases
+  static vector<cmplx<double>> std_test_values;
+  static vector<tuple<cmplx<double>, cmplx<double>>> comp_test_values;
+
+  static const char *test_name;
+
+  bool operator()(sycl::queue &Q) {
+    bool test_passes = true;
+
+    for (auto &test_value : std_test_values) {
+      test_passes &= test_valid_types<test_struct>(Q, test_value);
+    }
+
+    for (auto &test_tuple : comp_test_values) {
+      test_passes &= test_valid_types<test_struct>(Q, get<0>(test_tuple),
+                                                   get<1>(test_tuple),
+                                                   /*use_ref*/ true);
+    }
+
+    if (!test_passes)
+      std::cerr << test_name << " failed\n";
+
+    return test_passes;
+  }
+};
+
+template <template <typename> typename test_struct>
+vector<cmplx<double>> test_cases<test_struct>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(INFINITYd, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+    cmplx(NANd, INFINITYd),
+    cmplx(INFINITYd, NANd),
+};
+
+template <template <typename> typename test_struct>
+vector<tuple<cmplx<double>, cmplx<double>>>
+    test_cases<test_struct>::comp_test_values = {};
+
+// test_acos
+template <> const char *test_cases<test_acos>::test_name = "acos test";
+
+// test_asin
+template <> const char *test_cases<test_asin>::test_name = "asin test";
+
+// test_atan
+template <> const char *test_cases<test_atan>::test_name = "atan test";
+
+template <>
+vector<cmplx<double>> test_cases<test_atan>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(INFINITYd, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+    cmplx(NANd, INFINITYd),
+};
+
+// MSVC complex handles some error codes differently
+// So check against reference value
+template <>
+vector<tuple<cmplx<double>, cmplx<double>>>
+    test_cases<test_atan>::comp_test_values = {
+        tuple(cmplx(INFINITYd, NANd), cmplx(PI / 2.0, 0.0))};
+
+// test_acosh
+template <> const char *test_cases<test_acosh>::test_name = "acosh test";
+
+// test_asinh
+template <> const char *test_cases<test_asinh>::test_name = "asinh test";
+
+// test_atanh
+template <> const char *test_cases<test_atanh>::test_name = "atanh test";
+
+template <>
+vector<cmplx<double>> test_cases<test_atanh>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(INFINITYd, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+    cmplx(INFINITYd, NANd),
+};
+
+// MSVC complex handles some error codes differently
+// So check against reference value
+template <>
+vector<tuple<cmplx<double>, cmplx<double>>>
+    test_cases<test_atanh>::comp_test_values = {
+        tuple(cmplx(NANd, INFINITYd), cmplx(0.0, PI / 2.0))};
+
+// test_conj
+template <> const char *test_cases<test_conj>::test_name = "conj test";
+
+// test_cos
+template <> const char *test_cases<test_cos>::test_name = "cos test";
+
+// test_cosh
+template <> const char *test_cases<test_cosh>::test_name = "cosh test";
+
+// test_exp
+template <> const char *test_cases<test_exp>::test_name = "exp test";
+
+// test_log
+template <> const char *test_cases<test_log>::test_name = "log test";
+
+// test_log10
+template <> const char *test_cases<test_log10>::test_name = "log10 test";
+
+// test_proj
+template <> const char *test_cases<test_proj>::test_name = "proj test";
+
+// test_sin
+template <> const char *test_cases<test_sin>::test_name = "sin test";
+
+// test_sinh
+template <> const char *test_cases<test_sinh>::test_name = "sinh test";
+
+// test_sqrt
+template <> const char *test_cases<test_sqrt>::test_name = "sqrt test";
+
+// test_tan
+template <> const char *test_cases<test_tan>::test_name = "tan test";
+
+template <>
+vector<cmplx<double>> test_cases<test_tan>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+    cmplx(INFINITYd, NANd),
+};
+
+// MSVC complex handles some error codes differently
+// So check against reference value
+template <>
+vector<tuple<cmplx<double>, cmplx<double>>>
+    test_cases<test_tan>::comp_test_values = {
+        tuple(cmplx(INFINITYd, INFINITYd), cmplx(0.0, 1.0)),
+        tuple(cmplx(NANd, INFINITYd), cmplx(0.0, 1.0))};
+
+// test_tanh
+template <> const char *test_cases<test_tanh>::test_name = "tanh test";
+
+template <>
+vector<cmplx<double>> test_cases<test_tanh>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+    cmplx(NANd, INFINITYd),
+};
+
+// MSVC complex handles some error codes differently
+// So check against reference value
+template <>
+vector<tuple<cmplx<double>, cmplx<double>>>
+    test_cases<test_tanh>::comp_test_values = {
+        tuple(cmplx(INFINITYd, INFINITYd), cmplx(1.0, 0.0)),
+        tuple(cmplx(INFINITYd, NANd), cmplx(1.0, 0.0))};
+
+// test_abs
+template <> const char *test_cases<test_abs>::test_name = "abs test";
+
+// test_arg
+template <> const char *test_cases<test_arg>::test_name = "arg test";
+
+// test_norm
+// Difference between libstdc++ and libc++ when NaN's and Inf values are
+// combined.
+template <>
+vector<cmplx<double>> test_cases<test_norm>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(-1, 1),
+    cmplx(1, -1),
+    cmplx(-1, -1),
+    cmplx(INFINITYd, 2.02),
+    cmplx(4.42, INFINITYd),
+    cmplx(INFINITYd, INFINITYd),
+    cmplx(NANd, 2.02),
+    cmplx(4.42, NANd),
+    cmplx(NANd, NANd),
+};
+
+template <> const char *test_cases<test_norm>::test_name = "norm test";
+
+// test_polar
+// Note: values represent rho and theta, not real and imaginary values
+// Output is undefined if rho is negative or Nan, or theta is Inf
+template <>
+vector<cmplx<double>> test_cases<test_polar>::std_test_values = {
+    cmplx(1, 1),
+    cmplx(1, -1),
+    cmplx(2, 0),
+    cmplx(0.5, 3.14),
+};
+
+template <> const char *test_cases<test_polar>::test_name = "polar test";
diff --git a/SYCL/Complex/sycl_complex_operator_test.cpp b/SYCL/Complex/sycl_complex_operator_test.cpp
new file mode 100644
index 0000000000..fff51c6b23
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_operator_test.cpp
@@ -0,0 +1,139 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %HOST_RUN_PLACEHOLDER %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_helper.hpp"
+#include "sycl_complex_operator_test_cases.hpp"
+
+#define test_op(name, op)                                                      \
+  template <typename T> struct name {                                          \
+    bool operator()(sycl::queue &Q, T init_re1, T init_im1, T init_re2,        \
+                    T init_im2) {                                              \
+      bool pass = true;                                                        \
+                                                                               \
+      auto std_in1 = init_std_complex(init_re1, init_im1);                     \
+      auto std_in2 = init_std_complex(init_re2, init_im2);                     \
+      experimental::complex<T> cplx_input1{init_re1, init_im1};                \
+      experimental::complex<T> cplx_input2{init_re2, init_im2};                \
+                                                                               \
+      auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);    \
+                                                                               \
+      std::complex<T> std_out;                                                 \
+      std_out = std_in1 op std_in2;                                            \
+                                                                               \
+      Q.single_task([=]() {                                                    \
+         cplx_out[0] = cplx_input1 op cplx_input2;                             \
+       }).wait();                                                              \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);         \
+                                                                               \
+      cplx_out[0] = cplx_input1 op cplx_input2;                                \
+                                                                               \
+      pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);        \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+test_op(test_add, +);
+test_op(test_sub, -);
+test_op(test_mul, *);
+test_op(test_div, /);
+
+#undef test_op
+
+#define test_op_assign(name, op_assign)                                        \
+  template <typename T> struct name {                                          \
+    bool operator()(sycl::queue &Q, T init_re1, T init_im1, T init_re2,        \
+                    T init_im2) {                                              \
+      bool pass = true;                                                        \
+                                                                               \
+      auto std_in = init_std_complex(init_re1, init_im1);                      \
+      experimental::complex<T> cplx_input{init_re1, init_im1};                 \
+                                                                               \
+      auto std_inout = init_std_complex(init_re2, init_im2);                   \
+      auto *cplx_inout = sycl::malloc_shared<experimental::complex<T>>(1, Q);  \
+      cplx_inout[0].real(init_re2);                                            \
+      cplx_inout[0].imag(init_im2);                                            \
+                                                                               \
+      std_inout op_assign std_in;                                              \
+                                                                               \
+      Q.single_task([=]() { cplx_inout[0] op_assign cplx_input; }).wait();     \
+                                                                               \
+      pass &= check_results(                                                   \
+          cplx_inout[0], std::complex<T>(std_inout.real(), std_inout.imag()),  \
+          /*is_device*/ true);                                                 \
+                                                                               \
+      cplx_inout[0].real(init_re2);                                            \
+      cplx_inout[0].imag(init_im2);                                            \
+                                                                               \
+      cplx_inout[0] op_assign cplx_input;                                      \
+                                                                               \
+      pass &= check_results(                                                   \
+          cplx_inout[0], std::complex<T>(std_inout.real(), std_inout.imag()),  \
+          /*is_device*/ false);                                                \
+                                                                               \
+      sycl::free(cplx_inout, Q);                                               \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+test_op_assign(test_add_assign, +=);
+test_op_assign(test_sub_assign, -=);
+test_op_assign(test_mul_assign, *=);
+test_op_assign(test_div_assign, /=);
+
+#undef test_op_assign
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  {
+    test_cases<test_add> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_sub> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_mul> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_div> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_add_assign> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_sub_assign> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_mul_assign> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_div_assign> test;
+    test_passes &= test(Q);
+  }
+
+  return !test_passes;
+}
diff --git a/SYCL/Complex/sycl_complex_operator_test_cases.hpp b/SYCL/Complex/sycl_complex_operator_test_cases.hpp
new file mode 100644
index 0000000000..088d5512d8
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_operator_test_cases.hpp
@@ -0,0 +1,76 @@
+using std::pair;
+using std::vector;
+
+// Forward decleration of tests
+
+template <typename T> class test_add;
+template <typename T> class test_sub;
+template <typename T> class test_mul;
+template <typename T> class test_div;
+
+template <typename T> class test_add_assign;
+template <typename T> class test_sub_assign;
+template <typename T> class test_mul_assign;
+template <typename T> class test_div_assign;
+
+// Stores test cases for each math function used in sycl_complex_math_test.cpp
+// Values are stored in the highest precision type, in this case that is double
+
+template <template <typename> typename test_struct> struct test_cases {
+  static vector<pair<cmplx<double>, cmplx<double>>> test_values;
+  static const char *test_name;
+
+  bool operator()(sycl::queue &Q) {
+    bool test_passes = true;
+
+    for (auto &test_value : test_values) {
+      test_passes &= test_valid_types<test_struct>(
+          Q, test_value.first.re, test_value.first.im, test_value.second.re,
+          test_value.second.im);
+    }
+
+    if (!test_passes)
+      std::cerr << test_name << " failed\n";
+
+    return test_passes;
+  }
+};
+
+template <template <typename> typename test_struct>
+vector<pair<cmplx<double>, cmplx<double>>>
+    test_cases<test_struct>::test_values = {
+        pair(cmplx(-1, 1), cmplx(1, 1)),  pair(cmplx(-1, 1), cmplx(-1, 1)),
+        pair(cmplx(-1, 1), cmplx(1, -1)), pair(cmplx(-1, 1), cmplx(-1, -1)),
+
+        pair(cmplx(1, 1), cmplx(-1, 1)),  pair(cmplx(-1, 1), cmplx(-1, 1)),
+        pair(cmplx(1, -1), cmplx(-1, 1)), pair(cmplx(-1, -1), cmplx(-1, 1)),
+};
+
+// test_add
+template <> const char *test_cases<test_add>::test_name = "addition test";
+
+// test_sub
+template <> const char *test_cases<test_sub>::test_name = "subtraction test";
+
+// test_mul
+template <> const char *test_cases<test_mul>::test_name = "multiplication test";
+
+// test_div
+template <> const char *test_cases<test_div>::test_name = "division test";
+
+// test_add_assign
+template <>
+const char *test_cases<test_add_assign>::test_name = "addition assign test";
+
+// test_sub_assign
+template <>
+const char *test_cases<test_sub_assign>::test_name = "subtraction assign test";
+
+// test_mul_assign
+template <>
+const char *test_cases<test_mul_assign>::test_name =
+    "muliplication assign test";
+
+// test_div_assign
+template <>
+const char *test_cases<test_div_assign>::test_name = "division assign test";
diff --git a/SYCL/Complex/sycl_complex_pow_test.cpp b/SYCL/Complex/sycl_complex_pow_test.cpp
new file mode 100644
index 0000000000..dd238cbb68
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_pow_test.cpp
@@ -0,0 +1,269 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %HOST_RUN_PLACEHOLDER %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_helper.hpp"
+
+using std::get;
+using std::pair;
+using std::tuple;
+using std::vector;
+
+template <template <typename> typename test_struct> struct test_cases {
+  static vector<pair<cmplx<double>, cmplx<double>>> std_test_values;
+
+  static vector<tuple<cmplx<double>, cmplx<double>, cmplx<double>>>
+      comp_test_values;
+
+  static const char *test_name;
+
+  bool operator()(sycl::queue &Q) {
+    bool test_passes = true;
+
+    for (auto &test_pair : std_test_values) {
+      test_passes &=
+          test_valid_types<test_struct>(Q, test_pair.first, test_pair.second);
+    }
+
+    for (auto &test_tuple : comp_test_values) {
+      test_passes &= test_valid_types<test_struct>(
+          Q, get<0>(test_tuple), get<1>(test_tuple), get<2>(test_tuple),
+          /*use_ref*/ true);
+    }
+
+    if (!test_passes)
+      std::cerr << test_name << " failed\n";
+
+    return test_passes;
+  }
+};
+
+// Tests for different pow function overloads
+
+template <typename T> struct test_pow_cplx_cplx {
+  bool operator()(sycl::queue &Q, cmplx<T> init1, cmplx<T> init2,
+                  cmplx<T> ref = {0, 0}, bool use_ref = false) {
+    bool pass = true;
+
+    auto std_in1 = init_std_complex(init1.re, init1.im);
+    auto std_in2 = init_std_complex(init2.re, init2.im);
+    experimental::complex<T> cplx_input1{init1.re, init1.im};
+    experimental::complex<T> cplx_input2{init2.re, init2.im};
+
+    auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);
+
+    // Get std::complex output
+    std::complex<T> std_out{ref.re, ref.im};
+    if (!use_ref)
+      std_out = std::pow(std_in1, std_in2);
+
+    // Check cplx::complex output from device
+    Q.single_task([=]() {
+       cplx_out[0] = experimental::pow<T>(cplx_input1, cplx_input2);
+     }).wait();
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);
+
+    // Check cplx::complex output from host
+    cplx_out[0] = experimental::pow<T>(cplx_input1, cplx_input2);
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+// Only real component of init2 is used
+template <typename T> struct test_pow_cplx_deci {
+  bool operator()(sycl::queue &Q, cmplx<T> init1, cmplx<T> init2,
+                  cmplx<T> ref = {0, 0}, bool use_ref = false) {
+    bool pass = true;
+
+    auto std_in = init_std_complex(init1.re, init1.im);
+    auto std_deci_in = init_deci(init2.re);
+    experimental::complex<T> cplx_input{init1.re, init1.im};
+    T deci_input = init2.re;
+
+    auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);
+
+    // Get std::complex output
+    std::complex<T> std_out{ref.re, ref.im};
+    if (!use_ref)
+      std_out = std::pow(std_in, std_deci_in);
+
+    // Check cplx::complex output from device
+    Q.single_task([=]() {
+       cplx_out[0] = experimental::pow(cplx_input, deci_input);
+     }).wait();
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);
+
+    // Check cplx::complex output from host
+    cplx_out[0] = experimental::pow(cplx_input, deci_input);
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+// Only real component of init1 is used
+template <typename T> struct test_pow_deci_cplx {
+  bool operator()(sycl::queue &Q, cmplx<T> init1, cmplx<T> init2,
+                  cmplx<T> ref = {0, 0}, bool use_ref = false) {
+    bool pass = true;
+
+    auto std_in = init_std_complex(init2.re, init2.im);
+    auto std_deci_in = init_deci(init1.re);
+    experimental::complex<T> cplx_input{init2.re, init2.im};
+    T deci_input = init1.re;
+
+    auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);
+
+    // Get std::complex output
+    std::complex<T> std_out{ref.re, ref.im};
+    if (!use_ref)
+      std_out = std::pow(std_deci_in, std_in);
+
+    // Check cplx::complex output from device
+    Q.single_task([=]() {
+       cplx_out[0] = experimental::pow(deci_input, cplx_input);
+     }).wait();
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ true);
+
+    // Check cplx::complex output from host
+    cplx_out[0] = experimental::pow(deci_input, cplx_input);
+
+    pass &= check_results(cplx_out[0], std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+// test_pow_cplx_cplx
+template <>
+vector<pair<cmplx<double>, cmplx<double>>>
+    test_cases<test_pow_cplx_cplx>::std_test_values = {
+        pair(cmplx(4.5, 2.0), cmplx(3.0, 1.5)),
+        pair(cmplx(9.0, 0.0), cmplx(0.5, 0.0)),
+        pair(cmplx(1.0, 1.0), cmplx(-1.0, -1.0)),
+        pair(cmplx(1.0, 1.0), cmplx(0.5, 0.5)),
+        pair(cmplx(-1.0, -1.0), cmplx(-1.0, -1.0)),
+};
+
+template <>
+vector<tuple<cmplx<double>, cmplx<double>, cmplx<double>>> test_cases<
+    test_pow_cplx_cplx>::comp_test_values = {
+    tuple(cmplx(INFINITYd, 2.02), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+    tuple(cmplx(4.42, INFINITYd), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+    tuple(cmplx(INFINITYd, INFINITYd), cmplx(4.42, 2.02),
+          cmplx(INFINITYd, NANd)),
+    tuple(cmplx(NANd, 2.02), cmplx(4.42, 2.02), cmplx(NANd, NANd)),
+    tuple(cmplx(4.42, NANd), cmplx(4.42, 2.02), cmplx(NANd, NANd)),
+    tuple(cmplx(NANd, NANd), cmplx(4.42, 2.02), cmplx(NANd, NANd)),
+    tuple(cmplx(NANd, INFINITYd), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+    tuple(cmplx(INFINITYd, NANd), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+    tuple(cmplx(NANd, INFINITYd), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+    tuple(cmplx(INFINITYd, NANd), cmplx(4.42, 2.02), cmplx(INFINITYd, NANd)),
+};
+
+template <>
+const char *test_cases<test_pow_cplx_cplx>::test_name =
+    "pow complex complex test";
+
+// test_pow_cplx_deci
+template <>
+vector<pair<cmplx<double>, cmplx<double>>>
+    test_cases<test_pow_cplx_deci>::std_test_values = {
+        pair(cmplx(4.5, 2.0), cmplx(3.0, 0.0)),
+        pair(cmplx(9.0, 0.0), cmplx(0.5, 0.0)),
+        pair(cmplx(1.0, 1.0), cmplx(-1.0, 0.0)),
+        pair(cmplx(1.0, 1.0), cmplx(0.5, 0.0)),
+        pair(cmplx(-1.0, -1.0), cmplx(-1.0, -0.0)),
+};
+
+template <>
+vector<tuple<cmplx<double>, cmplx<double>, cmplx<double>>>
+    test_cases<test_pow_cplx_deci>::comp_test_values = {
+        tuple(cmplx(INFINITYd, 2.02), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+        tuple(cmplx(4.42, INFINITYd), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+        tuple(cmplx(INFINITYd, INFINITYd), cmplx(4.42, 0.0),
+              cmplx(INFINITYd, NANd)),
+        tuple(cmplx(NANd, 2.02), cmplx(4.42, 0.0), cmplx(NANd, NANd)),
+        tuple(cmplx(4.42, NANd), cmplx(4.42, 0.0), cmplx(NANd, NANd)),
+        tuple(cmplx(NANd, NANd), cmplx(4.42, 0.0), cmplx(NANd, NANd)),
+        tuple(cmplx(NANd, INFINITYd), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+        tuple(cmplx(INFINITYd, NANd), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+        tuple(cmplx(NANd, INFINITYd), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+        tuple(cmplx(INFINITYd, NANd), cmplx(4.42, 0.0), cmplx(INFINITYd, NANd)),
+};
+
+template <>
+const char *test_cases<test_pow_cplx_deci>::test_name =
+    "pow complex decimal test";
+
+// test_pow_deci_cplx
+template <>
+vector<pair<cmplx<double>, cmplx<double>>>
+    test_cases<test_pow_deci_cplx>::std_test_values = {
+        pair(cmplx(4.5, 0.0), cmplx(3.0, 1.5)),
+        pair(cmplx(9.0, 0.0), cmplx(0.5, 0.0)),
+        pair(cmplx(1.0, 0.0), cmplx(-1.0, -1.0)),
+        pair(cmplx(1.0, 0.0), cmplx(0.5, 0.5)),
+        pair(cmplx(-1.0, 0.0), cmplx(-1.0, -1.0)),
+};
+
+template <>
+vector<tuple<cmplx<double>, cmplx<double>, cmplx<double>>> test_cases<
+    test_pow_deci_cplx>::comp_test_values = {
+    tuple(cmplx(4.42, 0.0), cmplx(INFINITYd, 2.02), cmplx(INFINITYd, -NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(4.42, INFINITYd), cmplx(NANd, -NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(INFINITYd, INFINITYd),
+          cmplx(INFINITYd, NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(NANd, 2.02), cmplx(NANd, NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(4.42, NANd), cmplx(NANd, NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(NANd, NANd), cmplx(NANd, NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(NANd, INFINITYd), cmplx(-NANd, -NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(INFINITYd, NANd), cmplx(INFINITYd, -NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(NANd, INFINITYd), cmplx(-NANd, -NANd)),
+    tuple(cmplx(4.42, 0.0), cmplx(INFINITYd, NANd), cmplx(INFINITYd, -NANd)),
+};
+
+template <>
+const char *test_cases<test_pow_deci_cplx>::test_name =
+    "pow decimal complex test";
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  {
+    test_cases<test_pow_cplx_cplx> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_pow_cplx_deci> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    test_cases<test_pow_deci_cplx> test;
+    test_passes &= test(Q);
+  }
+
+  if (!test_passes)
+    std::cerr << "pow test failed\n";
+
+  return !test_passes;
+}
diff --git a/SYCL/Complex/sycl_complex_stream_test.cpp b/SYCL/Complex/sycl_complex_stream_test.cpp
new file mode 100644
index 0000000000..d423b13802
--- /dev/null
+++ b/SYCL/Complex/sycl_complex_stream_test.cpp
@@ -0,0 +1,85 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %HOST_RUN_PLACEHOLDER %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_helper.hpp"
+
+template <typename T> struct test_sycl_stream_operator {
+  bool operator()(sycl::queue &Q, cmplx<T> init) {
+    auto *cplx_out = sycl::malloc_shared<experimental::complex<T>>(1, Q);
+    cplx_out[0] = experimental::complex<T>(init.re, init.im);
+
+    Q.submit([&](sycl::handler &CGH) {
+       sycl::stream Out(512, 20, CGH);
+       CGH.parallel_for<>(sycl::range<1>(1), [=](sycl::id<1> idx) {
+         Out << cplx_out[idx] << sycl::endl;
+       });
+     }).wait();
+
+    sycl::free(cplx_out, Q);
+    return true;
+  }
+};
+
+// Host only tests for std::basic_ostream and std::basic_istream
+template <typename T> struct test_ostream_operator {
+  bool operator()(cmplx<T> init) {
+    experimental::complex<T> c(init.re, init.im);
+
+    std::ostringstream os;
+    os << c;
+
+    std::ostringstream ref_oss;
+    ref_oss << "(" << init.re << "," << init.im << ")";
+
+    if (ref_oss.str() == os.str())
+      return true;
+    return false;
+  }
+};
+
+template <typename T> struct test_istream_operator {
+  bool operator()(cmplx<T> init) {
+    experimental::complex<T> c(init.re, init.im);
+
+    std::ostringstream ref_oss;
+    ref_oss << "(" << init.re << "," << init.im << ")";
+
+    std::istringstream iss(ref_oss.str());
+
+    iss >> c;
+
+    return check_results(c, std::complex<T>(init.re, init.im),
+                         /*is_device*/ false);
+  }
+};
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  test_passes &=
+      test_valid_types<test_sycl_stream_operator>(Q, cmplx(1.5, -1.0));
+  test_passes &=
+      test_valid_types<test_sycl_stream_operator>(Q, cmplx(INFINITY, INFINITY));
+  test_passes &=
+      test_valid_types<test_sycl_stream_operator>(Q, cmplx(NAN, NAN));
+
+  test_passes &= test_valid_types<test_ostream_operator>(cmplx(1.5, -1.0));
+  test_passes &=
+      test_valid_types<test_ostream_operator>(cmplx(INFINITY, INFINITY));
+  test_passes &= test_valid_types<test_ostream_operator>(cmplx(NAN, NAN));
+
+  test_passes &= test_valid_types<test_istream_operator>(cmplx(1.5, -1.0));
+  test_passes &=
+      test_valid_types<test_istream_operator>(cmplx(INFINITY, INFINITY));
+  test_passes &= test_valid_types<test_istream_operator>(cmplx(NAN, NAN));
+
+  if (!test_passes)
+    std::cerr << "Stream operator with complex test fails\n";
+
+  return !test_passes;
+}