vendor/libc++/libc++-release_39-r276489

37 files changed, 333 insertions, 361 deletions

diff --git a/test/std/numerics/complex.number/cases.h b/test/std/numerics/complex.number/cases.h
index cd6bd165a9d1..a2f85d11ca4d 100644
--- a/test/std/numerics/complex.number/cases.h
+++ b/test/std/numerics/complex.number/cases.h
@@ -17,7 +17,7 @@
 #include <complex>
 #include <cassert>
 
-std::complex<double> x[] =
+const std::complex<double> testcases[] =
 {
     std::complex<double>( 1.e-6,  1.e-6),
     std::complex<double>(-1.e-6,  1.e-6),
diff --git a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
index 30c95c3c88d9..7decea877fbd 100644
--- a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
@@ -30,7 +30,7 @@ test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
     static_assert(std::imag(val) == 0, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.imag() == x, "" );
-#endif    
+#endif
 }
 
 template <class T, int x>
@@ -44,7 +44,7 @@ test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
     static_assert(std::imag(val) == 0, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.imag() == x, "" );
-#endif    
+#endif
 }
 
 template <class T>
diff --git a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
index a5a4a35b13ca..491b35890c0c 100644
--- a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
@@ -30,7 +30,7 @@ test(typename std::enable_if<std::is_integral<T>::value>::type* = 0)
     static_assert(std::real(val) == val, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.real() == x, "" );
-#endif    
+#endif
 }
 
 template <class T, int x>
@@ -44,7 +44,7 @@ test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
     static_assert(std::real(val) == val, "");
     constexpr std::complex<T> t{val, val};
     static_assert(t.real() == x, "" );
-#endif    
+#endif
 }
 
 template <class T>
diff --git a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
index 45b59914e7f8..a2e53629f97d 100644
--- a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals::complex_literals;
 
 //  Make sure the types are right
@@ -25,14 +25,14 @@ int main()
     static_assert ( std::is_same<decltype( 3i    ), std::complex<double>>::value, "" );
     static_assert ( std::is_same<decltype( 3.0if ), std::complex<float>>::value, "" );
     static_assert ( std::is_same<decltype( 3if   ), std::complex<float>>::value, "" );
-    
+
     {
     std::complex<long double> c1 = 3.0il;
     assert ( c1 == std::complex<long double>(0, 3.0));
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -46,6 +46,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
index 0f31d595566c..67e0fa131fd0 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
@@ -7,14 +7,12 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
 #include <complex>
 #include <cassert>
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     std::complex<float> foo  = 1.0if;  // should fail w/conversion operator not found
-#else
-#error
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
index 46903bbd565d..09a6f270f759 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std::literals;
 
     {
@@ -24,7 +24,7 @@ int main()
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -38,6 +38,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
index 8bd8acd981bc..d11530d7803a 100644
--- a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
 // <chrono>
 
 #include <complex>
@@ -15,7 +16,6 @@
 
 int main()
 {
-#if _LIBCPP_STD_VER > 11 
     using namespace std;
 
     {
@@ -24,7 +24,7 @@ int main()
     auto c2 = 3il;
     assert ( c1 == c2 );
     }
-    
+
     {
     std::complex<double> c1 = 3.0i;
     assert ( c1 == std::complex<double>(0, 3.0));
@@ -38,6 +38,4 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
-
-#endif
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
index cb285117b15d..b4200fc81d40 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -28,7 +28,7 @@ test()
     c /= c2;
     assert(c.real() == 1);
     assert(c.imag() == 0);
-    
+
     std::complex<T> c3;
 
     c3 = c;
@@ -36,13 +36,13 @@ test()
     c3 /= ic;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 /= fc;
     assert(c3.real() ==  0.5);
     assert(c3.imag() == -0.5);
-    
+
 }
 
 int main()
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
index 8c16f4ced2cd..9b222b8a1d3c 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
@@ -36,7 +36,7 @@ test()
     c3 += ic;
     assert(c3.real() == 4);
     assert(c3.imag() == 6);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 += fc;
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
index 84d6e591306e..98b7197cb272 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
@@ -36,7 +36,7 @@ test()
     c3 *= ic;
     assert(c3.real() == -11.5);
     assert(c3.imag() ==   3.5);
-    
+
     c3 = c;
     std::complex<float> fc (1,1);
     c3 *= fc;
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index 86119678aa70..8d4712eece78 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -37,16 +37,16 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = x[i] / x[j];
-            switch (classify(x[i]))
+            std::complex<double> r = testcases[i] / testcases[j];
+            switch (classify(testcases[i]))
             {
             case zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -66,7 +66,7 @@ void test_edges()
                 }
                 break;
             case non_zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
@@ -86,7 +86,7 @@ void test_edges()
                 }
                 break;
             case inf:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
@@ -106,7 +106,7 @@ void test_edges()
                 }
                 break;
             case NaN:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -126,7 +126,7 @@ void test_edges()
                 }
                 break;
             case non_zero_nan:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == inf);
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 565eaa5657cd..8ead5bfb627a 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -39,16 +39,16 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = x[i] * x[j];
-            switch (classify(x[i]))
+            std::complex<double> r = testcases[i] * testcases[j];
+            switch (classify(testcases[i]))
             {
             case zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == zero);
@@ -68,7 +68,7 @@ void test_edges()
                 }
                 break;
             case non_zero:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == zero);
@@ -88,7 +88,7 @@ void test_edges()
                 }
                 break;
             case inf:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -108,7 +108,7 @@ void test_edges()
                 }
                 break;
             case NaN:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
@@ -128,7 +128,7 @@ void test_edges()
                 }
                 break;
             case non_zero_nan:
-                switch (classify(x[j]))
+                switch (classify(testcases[j]))
                 {
                 case zero:
                     assert(classify(r) == NaN);
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index f8ee306d7544..1b0cca0d5f69 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -36,94 +36,94 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = acos(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = acos(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             is_about(r.real(), pi/2);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             is_about(r.real(), pi/2);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), pi/2);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && x[i].real() != 0 && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && testcases[i].real() != 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             is_about(r.real(), pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), 0.75 * pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             is_about(r.real(), 0.25 * pi);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) != std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (!std::signbit(x[i].real()) && !std::signbit(x[i].imag()))
+        else if (!std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert( std::signbit(r.imag()));
         }
-        else if (std::signbit(x[i].real()) && !std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].real()) && !std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert( std::signbit(r.imag()));
         }
-        else if (std::signbit(x[i].real()) && std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(!std::signbit(r.imag()));
         }
-        else if (!std::signbit(x[i].real()) && std::signbit(x[i].imag()))
+        else if (!std::signbit(testcases[i].real()) && std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(!std::signbit(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index 88a5c798424d..f1aece20e6cf 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -36,91 +36,91 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = acosh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = acosh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(!std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (x[i].real() == 1 && x[i].imag() == 0)
+        else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi);
             else
                 is_about(r.imag(),  pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -0.75 * pi);
             else
                 is_about(r.imag(),  0.75 * pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -0.25 * pi);
             else
                 is_about(r.imag(),  0.25 * pi);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
@@ -128,7 +128,7 @@ void test_edges()
         else
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index c743be6488c6..cf6f7869bd1a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -36,77 +36,77 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = asin(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = asin(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if ( x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
-            if (x[i].real() > 0)
+            if (testcases[i].real() > 0)
                 is_about(r.real(),  pi/2);
             else
                 is_about(r.real(), - pi/2);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
-            if (std::signbit(x[i].real()))
+            if (std::signbit(testcases[i].real()))
                 is_about(r.real(), -pi/4);
             else
                 is_about(r.real(),  pi/4);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].real()) != std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].real()) != std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index 027bc6a98a99..011f9d6b4f2e 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -36,76 +36,76 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = asinh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = asinh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/4);
             else
                 is_about(r.imag(),  pi/4);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index 69bc95240141..8cc71f7bff27 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -35,11 +35,11 @@ test()
 void test_edges()
 {
     typedef std::complex<double> C;
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = atan(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = atan(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = atanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index b821109b751b..6dc6034ca3c6 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -36,89 +36,89 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = atanh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = atanh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if ( x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if ( testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::abs(x[i].real()) == 1 && x[i].imag() == 0)
+        else if (std::abs(testcases[i].real()) == 1 && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (x[i].imag() > 0)
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (testcases[i].imag() > 0)
                 is_about(r.imag(),  pi/2);
             else
                 is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
-            assert(std::signbit(x[i].real()) == std::signbit(r.real()));
-            if (std::signbit(x[i].imag()))
+            assert(std::signbit(testcases[i].real()) == std::signbit(r.real()));
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi/2);
             else
                 is_about(r.imag(),  pi/2);
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
         else
         {
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index f25c967cb1a7..e09163a7057d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -36,11 +36,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = cos(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = cos(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> z = cosh(t1);
         if (std::isnan(real(r)))
             assert(std::isnan(real(z)));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index acf4746389c8..0fd9cf79bcbf 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -36,72 +36,72 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = cosh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = cosh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && std::isinf(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
             assert(!std::signbit(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(cos(x[i].imag())));
+            assert(std::signbit(r.real()) == std::signbit(cos(testcases[i].imag())));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].real() * sin(x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].real() * sin(testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index e8b507572f1b..31317816fae0 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -34,73 +34,73 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = exp(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = exp(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 1.0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() != 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() != 0)
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].imag()) && std::abs(x[i].imag()) <= 1)
+        else if (std::isfinite(testcases[i].imag()) && std::abs(testcases[i].imag()) <= 1)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index 800b92474bf0..589b5969950d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -35,17 +35,17 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = log(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = log(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
-            if (std::signbit(x[i].real()))
+            if (std::signbit(testcases[i].real()))
             {
                 assert(std::isinf(r.real()));
                 assert(r.real() < 0);
-                if (std::signbit(x[i].imag()))
+                if (std::signbit(testcases[i].imag()))
                     is_about(r.imag(), -pi);
                 else
                     is_about(r.imag(), pi);
@@ -55,24 +55,24 @@ void test_edges()
                 assert(std::isinf(r.real()));
                 assert(r.real() < 0);
                 assert(r.imag() == 0);
-                assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+                assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
             }
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
-            if (x[i].imag() > 0)
+            if (testcases[i].imag() > 0)
                 is_about(r.imag(), pi/2);
             else
                 is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()) && r.real() > 0);
             if (r.imag() > 0)
@@ -80,44 +80,44 @@ void test_edges()
             else
                 is_about(r.imag(), -pi);
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()) && r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (x[i].real() == 1 && x[i].imag() == 0)
+        else if (testcases[i].real() == 1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && x[i].imag() == 1)
+        else if (testcases[i].real() == 0 && testcases[i].imag() == 1)
         {
             assert(r.real() == 0);
             is_about(r.imag(), pi/2);
         }
-        else if (x[i].real() == -1 && x[i].imag() == 0)
+        else if (testcases[i].real() == -1 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            if (std::signbit(x[i].imag()))
+            if (std::signbit(testcases[i].imag()))
                 is_about(r.imag(), -pi);
             else
                 is_about(r.imag(),  pi);
         }
-        else if (x[i].real() == 0 && x[i].imag() == -1)
+        else if (testcases[i].real() == 0 && testcases[i].imag() == -1)
         {
             assert(r.real() == 0);
             is_about(r.imag(), -pi/2);
         }
-        else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) < 1)
+        else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) < 1)
         {
             assert( std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isfinite(x[i].imag()) && abs(x[i]) > 1)
+        else if (std::isfinite(testcases[i].real()) && std::isfinite(testcases[i].imag()) && abs(testcases[i]) > 1)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
     }
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index ba03ebf8ad28..58286904ae25 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -35,11 +35,11 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = log10(x[i]);
-        std::complex<double> z = log(x[i])/std::log(10);
+        std::complex<double> r = log10(testcases[i]);
+        std::complex<double> z = log(testcases[i])/std::log(10);
         if (std::isnan(real(r)))
             assert(std::isnan(real(z)));
         else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 258193d257a8..157246947cfe 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(x[i], x[j]);
-            std::complex<double> z = exp(x[j] * log(x[i]));
+            std::complex<double> r = pow(testcases[i], testcases[j]);
+            std::complex<double> z = exp(testcases[j] * log(testcases[i]));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 03bd10d465d1..0752ea59f554 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(x[i], real(x[j]));
-            std::complex<double> z = exp(std::complex<double>(real(x[j])) * log(x[i]));
+            std::complex<double> r = pow(testcases[i], real(testcases[j]));
+            std::complex<double> z = exp(std::complex<double>(real(testcases[j])) * log(testcases[i]));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index a48498cea92c..aedeec8caacc 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -37,13 +37,13 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
-            std::complex<double> r = pow(real(x[i]), x[j]);
-            std::complex<double> z = exp(x[j] * log(std::complex<double>(real(x[i]))));
+            std::complex<double> r = pow(real(testcases[i]), testcases[j]);
+            std::complex<double> z = exp(testcases[j] * log(std::complex<double>(real(testcases[i]))));
             if (std::isnan(real(r)))
                 assert(std::isnan(real(z)));
             else
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index 068222a27373..e1b98ecd0677 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -36,11 +36,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sin(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = sin(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = sinh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index dcd30e48dff5..20f2e71b140a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -36,73 +36,73 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sinh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = sinh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (x[i].real() == 0 && std::isinf(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (x[i].real() == 0 && std::isnan(x[i].imag()))
+        else if (testcases[i].real() == 0 && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].imag() == 0)
+        else if (std::isinf(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
-            assert(std::signbit(r.real()) == std::signbit(x[i].real() * cos(x[i].imag())));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real() * cos(testcases[i].imag())));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(sin(x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(sin(testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 69309d2b9ab1..d3273179a6da 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -36,58 +36,58 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = sqrt(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = sqrt(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(!std::signbit(r.real()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isinf(r.imag()));
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 0);
             assert(!std::signbit(r.real()));
             assert(std::isinf(r.imag()));
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isfinite(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(r.imag() == 0);
-            assert(std::signbit(x[i].imag()) == std::signbit(r.imag()));
+            assert(std::signbit(testcases[i].imag()) == std::signbit(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() < 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() < 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isinf(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && x[i].real() > 0 && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && testcases[i].real() > 0 && std::isnan(testcases[i].imag()))
         {
             assert(std::isinf(r.real()));
             assert(r.real() > 0);
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && (std::isfinite(x[i].imag()) || std::isnan(x[i].imag())))
+        else if (std::isnan(testcases[i].real()) && (std::isfinite(testcases[i].imag()) || std::isnan(testcases[i].imag())))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::signbit(x[i].imag()))
+        else if (std::signbit(testcases[i].imag()))
         {
             assert(!std::signbit(r.real()));
             assert(std::signbit(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index 881427600686..041a7814d033 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -37,11 +37,11 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = tan(x[i]);
-        std::complex<double> t1(-imag(x[i]), real(x[i]));
+        std::complex<double> r = tan(testcases[i]);
+        std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = tanh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index 907c0e64dba9..9a2276a8b753 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -36,55 +36,55 @@ void test_edges()
 {
     typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = tanh(x[i]);
-        if (x[i].real() == 0 && x[i].imag() == 0)
+        std::complex<double> r = tanh(testcases[i]);
+        if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
-            assert(std::signbit(r.real()) == std::signbit(x[i].real()));
+            assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isfinite(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isfinite(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isinf(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(sin(2*x[i].imag())));
+            assert(std::signbit(r.imag()) == std::signbit(sin(2*testcases[i].imag())));
         }
-        else if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
         }
-        else if (std::isinf(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isinf(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);
         }
-        else if (std::isnan(x[i].real()) && x[i].imag() == 0)
+        else if (std::isnan(testcases[i].real()) && testcases[i].imag() == 0)
         {
             assert(std::isnan(r.real()));
             assert(r.imag() == 0);
-            assert(std::signbit(r.imag()) == std::signbit(x[i].imag()));
+            assert(std::signbit(r.imag()) == std::signbit(testcases[i].imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isfinite(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isfinite(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
         }
-        else if (std::isnan(x[i].real()) && std::isnan(x[i].imag()))
+        else if (std::isnan(testcases[i].real()) && std::isnan(testcases[i].imag()))
         {
             assert(std::isnan(r.real()));
             assert(std::isnan(r.imag()));
diff --git a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 5d841d6ee9f1..7a0e3bd70072 100644
--- a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -28,11 +28,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = abs(x[i]);
-        switch (classify(x[i]))
+        double r = abs(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
             assert(r == 0);
diff --git a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index a7da456b979c..78f2781b76e2 100644
--- a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -29,42 +29,42 @@ test()
 void test_edges()
 {
     const double pi = std::atan2(+0., -0.);
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = arg(x[i]);
-        if (std::isnan(x[i].real()) || std::isnan(x[i].imag()))
+        double r = arg(testcases[i]);
+        if (std::isnan(testcases[i].real()) || std::isnan(testcases[i].imag()))
             assert(std::isnan(r));
         else
         {
-            switch (classify(x[i]))
+            switch (classify(testcases[i]))
             {
             case zero:
-                if (std::signbit(x[i].real()))
+                if (std::signbit(testcases[i].real()))
                 {
-                    if (std::signbit(x[i].imag()))
+                    if (std::signbit(testcases[i].imag()))
                         is_about(r, -pi);
                     else
                         is_about(r, pi);
                 }
                 else
                 {
-                    assert(std::signbit(x[i].imag()) == std::signbit(r));
+                    assert(std::signbit(testcases[i].imag()) == std::signbit(r));
                 }
                 break;
             case non_zero:
-                if (x[i].real() == 0)
+                if (testcases[i].real() == 0)
                 {
-                    if (x[i].imag() < 0)
+                    if (testcases[i].imag() < 0)
                         is_about(r, -pi/2);
                     else
                         is_about(r, pi/2);
                 }
-                else if (x[i].imag() == 0)
+                else if (testcases[i].imag() == 0)
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (std::signbit(x[i].imag()))
+                        if (std::signbit(testcases[i].imag()))
                             is_about(r, -pi);
                         else
                             is_about(r, pi);
@@ -72,37 +72,37 @@ void test_edges()
                     else
                     {
                         assert(r == 0);
-                        assert(std::signbit(x[i].imag()) == std::signbit(r));
+                        assert(std::signbit(testcases[i].imag()) == std::signbit(r));
                     }
                 }
-                else if (x[i].imag() > 0)
+                else if (testcases[i].imag() > 0)
                     assert(r > 0);
                 else
                     assert(r < 0);
                 break;
             case inf:
-                if (std::isinf(x[i].real()) && std::isinf(x[i].imag()))
+                if (std::isinf(testcases[i].real()) && std::isinf(testcases[i].imag()))
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (x[i].imag() > 0)
+                        if (testcases[i].imag() > 0)
                             is_about(r, 0.75 * pi);
                         else
                             is_about(r, -0.75 * pi);
                     }
                     else
                     {
-                        if (x[i].imag() > 0)
+                        if (testcases[i].imag() > 0)
                             is_about(r, 0.25 * pi);
                         else
                             is_about(r, -0.25 * pi);
                     }
                 }
-                else if (std::isinf(x[i].real()))
+                else if (std::isinf(testcases[i].real()))
                 {
-                    if (x[i].real() < 0)
+                    if (testcases[i].real() < 0)
                     {
-                        if (std::signbit(x[i].imag()))
+                        if (std::signbit(testcases[i].imag()))
                             is_about(r, -pi);
                         else
                             is_about(r, pi);
@@ -110,12 +110,12 @@ void test_edges()
                     else
                     {
                         assert(r == 0);
-                        assert(std::signbit(r) == std::signbit(x[i].imag()));
+                        assert(std::signbit(r) == std::signbit(testcases[i].imag()));
                     }
                 }
                 else
                 {
-                    if (x[i].imag() < 0)
+                    if (testcases[i].imag() < 0)
                         is_about(r, -pi/2);
                     else
                         is_about(r, pi/2);
diff --git a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index 48f774e8e1c9..da7ad14bedce 100644
--- a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -28,11 +28,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = norm(x[i]);
-        switch (classify(x[i]))
+        double r = norm(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
             assert(r == 0);
diff --git a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index a8747bd7c83b..5e6cb0d523c2 100644
--- a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -46,11 +46,11 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        double r = real(x[i]);
-        double theta = imag(x[i]);
+        double r = real(testcases[i]);
+        double theta = imag(testcases[i]);
         std::complex<double> z = std::polar(r, theta);
         switch (classify(r))
         {
diff --git a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index 10bf7f8576f6..1a7e0c53f3d3 100644
--- a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -37,26 +37,26 @@ test()
 
 void test_edges()
 {
-    const unsigned N = sizeof(x) / sizeof(x[0]);
+    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
-        std::complex<double> r = proj(x[i]);
-        switch (classify(x[i]))
+        std::complex<double> r = proj(testcases[i]);
+        switch (classify(testcases[i]))
         {
         case zero:
         case non_zero:
-            assert(r == x[i]);
-            assert(std::signbit(real(r)) == std::signbit(real(x[i])));
-            assert(std::signbit(imag(r)) == std::signbit(imag(x[i])));
+            assert(r == testcases[i]);
+            assert(std::signbit(real(r)) == std::signbit(real(testcases[i])));
+            assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
             break;
         case inf:
             assert(std::isinf(real(r)) && real(r) > 0);
             assert(imag(r) == 0);
-            assert(std::signbit(imag(r)) == std::signbit(imag(x[i])));
+            assert(std::signbit(imag(r)) == std::signbit(imag(testcases[i])));
             break;
         case NaN:
         case non_zero_nan:
-            assert(classify(r) == classify(x[i]));
+            assert(classify(r) == classify(testcases[i]));
             break;
         }
     }
diff --git a/test/std/numerics/complex.number/version.pass.cpp b/test/std/numerics/complex.number/version.pass.cpp
deleted file mode 100644
index 316cfec739a9..000000000000
--- a/test/std/numerics/complex.number/version.pass.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <complex>
-
-#include <complex>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}