[NFC] Strip trailing whitespace from libc++

15 files changed, 60 insertions, 60 deletions

diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/ceil2.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/ceil2.pass.cpp
index a469fad9257..5b66aca1400 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/ceil2.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/ceil2.pass.cpp
@@ -6,14 +6,14 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr T ceil2(T x) noexcept;
 
-// Returns: The minimal value y such that ispow2(y) is true and y >= x; 
+// Returns: The minimal value y such that ispow2(y) is true and y >= x;
 //    if y is not representable as a value of type T, the result is an unspecified value.
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
@@ -49,7 +49,7 @@ void runtime_test()
 {
     ASSERT_SAME_TYPE(T, decltype(std::ceil2(T(0))));
     LIBCPP_ASSERT_NOEXCEPT(      std::ceil2(T(0)));
-    
+
     assert( std::ceil2(T(60)) == T( 64));
     assert( std::ceil2(T(61)) == T( 64));
     assert( std::ceil2(T(62)) == T( 64));
@@ -64,11 +64,11 @@ void runtime_test()
 
 int main()
 {
-    
+
     {
     auto lambda = [](auto x) -> decltype(std::ceil2(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -104,7 +104,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/floor2.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/floor2.pass.cpp
index f6d183d5be1..9b4251c99bf 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/floor2.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/floor2.pass.cpp
@@ -6,13 +6,13 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr T floor2(T x) noexcept;
 
 // Returns: If x == 0, 0; otherwise the maximal value y such that floor2(y) is true and y <= x.
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -67,7 +67,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::floor2(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -103,7 +103,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/ispow2.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/ispow2.pass.cpp
index d65f8189896..6d60539f249 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/ispow2.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/ispow2.pass.cpp
@@ -6,12 +6,12 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr bool ispow2(T x) noexcept;
 
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -65,7 +65,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::ispow2(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -101,7 +101,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/log2p1.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/log2p1.pass.cpp
index 39054bcf905..55df3f1035e 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/log2p1.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/log2p1.pass.cpp
@@ -6,14 +6,14 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr T log2p1(T x) noexcept;
 
 // If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any fractional part discarded.
 
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -79,7 +79,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::log2p1(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -115,7 +115,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
index 28cb52545c0..f7d837ed396 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
@@ -6,7 +6,7 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int countl_one(T x) noexcept;
@@ -14,7 +14,7 @@
 // The number of consecutive 1 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == std::numeric_limits<T>::max(). ]
 //
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -71,7 +71,7 @@ int main()
 	{
     auto lambda = [](auto x) -> decltype(std::countl_one(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -107,7 +107,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
index af39dc2905c..d984f4de564 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
@@ -6,7 +6,7 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int countl_zero(T x) noexcept;
@@ -14,7 +14,7 @@
 // Returns: The number of consecutive 0 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == 0. ]
 //
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -72,7 +72,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::countl_zero(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -108,7 +108,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
index e82b1f365e1..96d1a93af3f 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
@@ -6,7 +6,7 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int countr_one(T x) noexcept;
@@ -14,7 +14,7 @@
 // Returns: The number of consecutive 1 bits, starting from the least significant bit.
 //   [ Note: Returns N if x == std::numeric_limits<T>::max(). ]
 //
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -71,7 +71,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::countr_one(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -107,7 +107,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
index 8d355bfb51b..730b645e76c 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
@@ -6,7 +6,7 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int countr_zero(T x) noexcept;
@@ -14,7 +14,7 @@
 // Returns: The number of consecutive 0 bits, starting from the most significant bit.
 //   [ Note: Returns N if x == 0. ]
 //
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -71,7 +71,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::countr_zero(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -107,7 +107,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
index e3934a1318d..adc044cc073 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
@@ -6,14 +6,14 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int popcount(T x) noexcept;
 
 // Returns: The number of bits set to one in the value of x.
 //
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //	T is an unsigned integer type
 
 #include <bit>
@@ -69,7 +69,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::popcount(x)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -105,7 +105,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L, __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
index 84ffe5b84a8..b408f5a3f3f 100644
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
@@ -6,12 +6,12 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int rotl(T x, unsigned int s) noexcept;
 
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
@@ -55,7 +55,7 @@ void runtime_test()
     ASSERT_SAME_TYPE(T, decltype(std::rotl(T(0), 0)));
     ASSERT_NOEXCEPT(             std::rotl(T(0), 0));
     const T val = std::numeric_limits<T>::max() - 1;
-    
+
     assert( std::rotl(val, 0) == val);
     assert( std::rotl(val, 1) == T((val << 1) +   1));
     assert( std::rotl(val, 2) == T((val << 2) +   3));
@@ -72,7 +72,7 @@ int main()
     {
     auto lambda = [](auto x) -> decltype(std::rotl(x, 1U)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -108,12 +108,12 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L,  __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A>, "");
     static_assert(!std::is_invocable_v<L, E1>, "");
     static_assert(!std::is_invocable_v<L, E2>, "");
     }
-    
+
     static_assert(constexpr_test<unsigned char>(),      "");
     static_assert(constexpr_test<unsigned short>(),     "");
     static_assert(constexpr_test<unsigned>(),           "");
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
index 4cd642f7374..7f1b29df15c 100644
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
@@ -6,12 +6,12 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // template <class T>
 //   constexpr int rotr(T x, unsigned int s) noexcept;
 
-// Remarks: This function shall not participate in overload resolution unless 
+// Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
@@ -69,7 +69,7 @@ void runtime_test()
         max - (max >> 6), // FC0 .. 0
         max - (max >> 7), // FE0 .. 0
         };
-    
+
     assert( std::rotr(val, 0) == val);
     assert( std::rotr(val, 1) == T((val >> 1) +  uppers[1]));
     assert( std::rotr(val, 2) == T((val >> 2) +  uppers[2]));
@@ -82,11 +82,11 @@ void runtime_test()
 
 int main()
 {
-    
+
     {
     auto lambda = [](auto x) -> decltype(std::rotr(x, 1U)) {};
     using L = decltype(lambda);
-    
+
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
@@ -122,7 +122,7 @@ int main()
     static_assert( std::is_invocable_v<L, __uint128_t>, "");
     static_assert(!std::is_invocable_v<L,  __int128_t>, "");
 #endif
- 
+
     static_assert(!std::is_invocable_v<L, A, unsigned>, "");
     static_assert(!std::is_invocable_v<L, E1, unsigned>, "");
     static_assert(!std::is_invocable_v<L, E2, unsigned>, "");
diff --git a/libcxx/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp b/libcxx/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp
index 2ab41c18225..7d9ceef8b48 100644
--- a/libcxx/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp
@@ -45,7 +45,7 @@ void test()
     assert((std::lerp(T( 0), T(12), T(1)) == T(12)));
     assert((std::lerp(T(12), T( 0), T(0)) == T(12)));
     assert((std::lerp(T(12), T( 0), T(1)) == T(0)));
-    
+
     assert((std::lerp(T( 0), T(12), T(0.5)) == T(6)));
     assert((std::lerp(T(12), T( 0), T(0.5)) == T(6)));
     assert((std::lerp(T( 0), T(12), T(2))   == T(24)));
@@ -66,10 +66,10 @@ int main(int, char**)
     static_assert(constexpr_test<float>(), "");
     static_assert(constexpr_test<double>(), "");
     static_assert(constexpr_test<long double>(), "");
-    
+
     test<float>();
     test<double>();
     test<long double>();
-    
+
     return 0;
 }
diff --git a/libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp b/libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
index 69c71cde043..35074e5772d 100644
--- a/libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
+++ b/libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
@@ -79,6 +79,6 @@ int main(int, char**)
     test<double>();
     test<long double>();
 //     test_constexpr<int> ();
-    
+
   return 0;
 }
diff --git a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.cpp b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.cpp
index c7576108af5..0e08d06d3e9 100644
--- a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.cpp
@@ -34,6 +34,6 @@ int main(int, char**)
     (void) std::midpoint(func1, func2);      // expected-error {{no matching function for call to 'midpoint'}}
     (void) std::midpoint(ip, ip);            // expected-error {{no matching function for call to 'midpoint'}}
     (void) std::midpoint(vp, vp);            // expected-error {{no matching function for call to 'midpoint'}}
-    
+
     return 0;
 }
diff --git a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
index 1956c97c987..be960119ac1 100644
--- a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
@@ -31,7 +31,7 @@ void signed_test()
     ASSERT_SAME_TYPE(decltype(std::midpoint(T(), T())), T);
     ASSERT_NOEXCEPT(          std::midpoint(T(), T()));
     using limits = std::numeric_limits<T>;
-    
+
     static_assert(std::midpoint(one, three) == two, "");
     static_assert(std::midpoint(three, one) == two, "");
 
@@ -53,7 +53,7 @@ void signed_test()
     assert(std::midpoint(T( 4), T(-3)) == T(1));
     assert(std::midpoint(T(-3), T(-4)) == T(-3));
     assert(std::midpoint(T(-4), T(-3)) == T(-4));
-    
+
     static_assert(std::midpoint(limits::min(), limits::max()) == T(-1), "");
     static_assert(std::midpoint(limits::max(), limits::min()) == T( 0), "");
 
@@ -81,7 +81,7 @@ void unsigned_test()
     ASSERT_NOEXCEPT(          std::midpoint(T(), T()));
     using limits = std::numeric_limits<T>;
     const T half_way = (limits::max() - limits::min())/2;
-    
+
     static_assert(std::midpoint(one, three) == two, "");
     static_assert(std::midpoint(three, one) == two, "");
 
@@ -94,7 +94,7 @@ void unsigned_test()
     assert(std::midpoint(four, one)    == three);
     assert(std::midpoint(three, four)  == three);
     assert(std::midpoint(four, three)  == four);
-    
+
     assert(std::midpoint(limits::min(), limits::max()) == T(half_way));
     assert(std::midpoint(limits::max(), limits::min()) == T(half_way + 1));