[libcxx] [test] Strip trailing whitespace.

[STL_MSFT]

Summary

[libcxx] [test] Strip trailing whitespace.

[STL_MSFT]

Thanks, r287829.

test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp

 #include <algorithm>
 #include <functional>
 #include <cassert>
 
 struct Tag {
     Tag() : val(0), tag("Default") {}
     Tag(int a, const char *b) : val(a), tag(b) {}
     ~Tag() {}
-        
     int val;
     const char *tag;
     };
-    
 bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
 // bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
 bool comp (const Tag& rhs, const Tag& lhs) { return rhs.val <  lhs.val; }
 
 
 template <class T, class C>
 void
 test(const T& v, const T& lo, const T& hi, C c, const T& x)

test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp

 
 #include <algorithm>
 #include <cassert>
 
 struct Tag {
   Tag() : val(0), tag("Default") {}
   Tag(int a, const char *b) : val(a), tag(b) {}
   ~Tag() {}
-    
   int val;
   const char *tag;
   };
-  
 bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
 // bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
 bool operator< (const Tag& rhs, const Tag& lhs) { return rhs.val <  lhs.val; }
 
 template <class T>
 void
 test(const T& a, const T& lo, const T& hi, const T& x)
 {

test/std/atomics/atomics.types.generic/integral.pass.cpp

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
   test<std::atomic_int8_t,    int8_t>();
   test<std::atomic_uint8_t,  uint8_t>();
   test<std::atomic_int16_t,   int16_t>();
   test<std::atomic_uint16_t, uint16_t>();
   test<std::atomic_int32_t,   int32_t>();
   test<std::atomic_uint32_t, uint32_t>();
   test<std::atomic_int64_t,   int64_t>();
   test<std::atomic_uint64_t, uint64_t>();
-  
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
     test<volatile std::atomic_uchar, unsigned char>();
     test<volatile std::atomic_short, short>();
     test<volatile std::atomic_ushort, unsigned short>();
     test<volatile std::atomic_int, int>();
     test<volatile std::atomic_uint, unsigned int>();
     test<volatile std::atomic_long, long>();

test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <map>
 
-// Check that std::map fails to instantiate if the comparison predicate is 
+// Check that std::map fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <map>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 

test/std/containers/associative/map/map.cons/copy_assign.pass.cpp

 
 template <class T>
 class counting_allocatorT {
 public:
     typedef T value_type;
     int foo{0};
     counting_allocatorT(int f) noexcept : foo(f) {}
 
-    using propagate_on_container_copy_assignment = std::true_type;    
+    using propagate_on_container_copy_assignment = std::true_type;
     template <class U> counting_allocatorT(const counting_allocatorT<U>& other) noexcept {foo = other.foo;}
     template <class U> bool operator==(const counting_allocatorT<U>& other) const noexcept { return foo == other.foo; }
     template <class U> bool operator!=(const counting_allocatorT<U>& other) const noexcept { return foo != other.foo; }
 
     T * allocate(const size_t n) const {
         ca_allocs.push_back(foo);
         void * const pv = ::malloc(n * sizeof(T));
         return static_cast<T *>(pv);
     }
     void deallocate(T * const p, size_t) const noexcept {
         ca_deallocs.push_back(foo);
         free(p);
     }
 };
 
 template <class T>
 class counting_allocatorF {
 public:
     typedef T value_type;
     int foo{0};
     counting_allocatorF(int f) noexcept : foo(f) {}
 
-    using propagate_on_container_copy_assignment = std::false_type;    
+    using propagate_on_container_copy_assignment = std::false_type;
     template <class U> counting_allocatorF(const counting_allocatorF<U>& other) noexcept {foo = other.foo;}
     template <class U> bool operator==(const counting_allocatorF<U>& other) const noexcept { return foo == other.foo; }
     template <class U> bool operator!=(const counting_allocatorF<U>& other) const noexcept { return foo != other.foo; }
 
     T * allocate(const size_t n) const {
         ca_allocs.push_back(foo);
         void * const pv = ::malloc(n * sizeof(T));
         return static_cast<T *>(pv);
     }
     void deallocate(T * const p, size_t) const noexcept {
         ca_deallocs.push_back(foo);
         free(p);
     }
 };
 
 bool balanced_allocs() {
     std::vector<int> temp1, temp2;
-    
     std::cout << "Allocations = " << ca_allocs.size() << ", deallocatons = " << ca_deallocs.size() << std::endl;
     if (ca_allocs.size() != ca_deallocs.size())
         return false;
 
     temp1 = ca_allocs;
     std::sort(temp1.begin(), temp1.end());
     temp2.clear();
     std::unique_copy(temp1.begin(), temp1.end(), std::back_inserter<std::vector<int>>(temp2));
     std::cout << "There were " << temp2.size() << " different allocators\n";
-    
     for (std::vector<int>::const_iterator it = temp2.begin(); it != temp2.end(); ++it ) {
         std::cout << *it << ": " << std::count(ca_allocs.begin(), ca_allocs.end(), *it) << " vs " << std::count(ca_deallocs.begin(), ca_deallocs.end(), *it) << std::endl;
         if ( std::count(ca_allocs.begin(), ca_allocs.end(), *it) != std::count(ca_deallocs.begin(), ca_deallocs.end(), *it))
             return false;
         }
-        
     temp1 = ca_allocs;
     std::sort(temp1.begin(), temp1.end());
     temp2.clear();
     std::unique_copy(temp1.begin(), temp1.end(), std::back_inserter<std::vector<int>>(temp2));
     std::cout << "There were " << temp2.size() << " different (de)allocators\n";
     for (std::vector<int>::const_iterator it = ca_deallocs.begin(); it != ca_deallocs.end(); ++it ) {
         std::cout << *it << ": " << std::count(ca_allocs.begin(), ca_allocs.end(), *it) << " vs " << std::count(ca_deallocs.begin(), ca_deallocs.end(), *it) << std::endl;
         if ( std::count(ca_allocs.begin(), ca_allocs.end(), *it) != std::count(ca_deallocs.begin(), ca_deallocs.end(), *it))
             return false;
         }
-    
     return true;
     }
 #endif
 
 int main()
 {
     {
         typedef std::pair<const int, double> V;

test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <map>
 
-// Check that std::multimap fails to instantiate if the comparison predicate is 
+// Check that std::multimap fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <map>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 

test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <set>
 
-// Check that std::multiset fails to instantiate if the comparison predicate is 
+// Check that std::multiset fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <set>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 

test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <set>
 
-// Check that std::set fails to instantiate if the comparison predicate is 
+// Check that std::set fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <set>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 

test/std/containers/sequences/vector/vector.data/data.pass.cpp

 
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 struct Nasty {
   Nasty() : i_(0) {}
   Nasty(int i) : i_(i) {}
   ~Nasty() {}
-  
   Nasty * operator&() const { assert(false); return nullptr; }
   int i_;
   };
 
 int main()
 {
     {
         std::vector<int> v;

test/std/containers/sequences/vector/vector.data/data_const.pass.cpp

 
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 struct Nasty {
   Nasty() : i_(0) {}
   Nasty(int i) : i_(i) {}
   ~Nasty() {}
-  
   Nasty * operator&() const { assert(false); return nullptr; }
   int i_;
   };
 
 int main()
 {
     {
         const std::vector<int> v;

test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 // The test requires access control SFINAE.
 
 // <unordered_map>
 
-// Check that std::unordered_map fails to instantiate if the comparison predicate is 
+// Check that std::unordered_map fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <unordered_map>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 

test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 // The test requires access control SFINAE.
 
 // <unordered_map>
 
-// Check that std::unordered_map fails to instantiate if the hash function is 
+// Check that std::unordered_map fails to instantiate if the hash function is
 // not copy-constructible. This is mentioned in LWG issue 2436
 
 #include <unordered_map>
 
 template <class T>
 struct Hash {
   std::size_t operator () (const T& lhs) const { return 0; }
 

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 // The test requires access control SFINAE.
 
 // <unordered_map>
 
-// Check that std::unordered_multimap fails to instantiate if the comparison predicate is 
+// Check that std::unordered_multimap fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <unordered_map>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 // The test requires access control SFINAE.
 
 // <unordered_map>
 
-// Check that std::unordered_multimap fails to instantiate if the hash function is 
+// Check that std::unordered_multimap fails to instantiate if the hash function is
 // not copy-constructible. This is mentioned in LWG issue 2436
 
 #include <unordered_map>
 
 template <class T>
 struct Hash {
   std::size_t operator () (const T& lhs) const { return 0; }
 

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
-// Check that std::unordered_set fails to instantiate if the comparison predicate is 
+// Check that std::unordered_set fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <unordered_set>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
-// Check that std::unordered_multiset fails to instantiate if the hash function is 
+// Check that std::unordered_multiset fails to instantiate if the hash function is
 // not copy-constructible. This is mentioned in LWG issue 2436
 
 #include <unordered_set>
 
 template <class T>
 struct Hash {
   std::size_t operator () (const T& lhs) const { return 0; }
 

test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
-// Check that std::unordered_set fails to instantiate if the comparison predicate is 
+// Check that std::unordered_set fails to instantiate if the comparison predicate is
 // not copy-constructible. This is LWG issue 2436
 
 #include <unordered_set>
 
 template <class T>
 struct Comp {
   bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 

test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
-// Check that std::unordered_set fails to instantiate if the hash function is 
+// Check that std::unordered_set fails to instantiate if the hash function is
 // not copy-constructible. This is mentioned in LWG issue 2436
 
 #include <unordered_set>
 
 template <class T>
 struct Hash {
   std::size_t operator () (const T& lhs) const { return 0; }
 

test/std/diagnostics/syserr/is_error_code_enum.pass.cpp

 
 // Specialize the template for my class
 namespace std
 {
   template <>
   struct is_error_code_enum<A> : public std::true_type {};
 }
 
-  
 int main()
 {
     test<false, void>();
     test<false, int>();
     test<false, std::nullptr_t>();
     test<false, std::string>();
 
     test<true, A>();
 }

test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp

 
 // Specialize the template for my class
 namespace std
 {
   template <>
   struct is_error_condition_enum<A> : public std::true_type {};
 }
 
-  
 int main()
 {
     test<false, void>();
     test<false, int>();
     test<false, std::nullptr_t>();
     test<false, std::string>();
-    
     test<true, A>();
 }

test/std/experimental/numeric/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type, the program is ill-formed.
 
 #include <experimental/numeric>
 
 
 int main()
 {
     std::experimental::gcd(2.0, 4);
 }

test/std/experimental/numeric/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type, the program is ill-formed.
 
 #include <experimental/numeric>
 
 
 int main()
 {
     std::experimental::gcd(4, 6.0);
 }

test/std/experimental/numeric/numeric.ops/numeric.ops.gcd/gcd.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 #include <experimental/numeric>
 #include <cassert>

test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type, the program is ill-formed.
 
 #include <experimental/numeric>
 
 
 int main()
 {
     std::experimental::lcm(4, 6.0);
 }

test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 #include <experimental/numeric>
 #include <cassert>

test/std/iterators/iterator.range/begin-end.fail.cpp

namespace Foo {
   FakeIter rbegin(const FakeContainer &)  { return 3; }
   FakeIter rend  (const FakeContainer &)  { return 4; }
 
   FakeIter cbegin(const FakeContainer &)  { return 11; }
   FakeIter cend  (const FakeContainer &)  { return 12; }
   FakeIter crbegin(const FakeContainer &) { return 13; }
   FakeIter crend  (const FakeContainer &) { return 14; }
 }
-  
 
 int main(){
 // Bug #28927 - shouldn't find these via ADL
   (void) std::cbegin (Foo::FakeContainer());
   (void) std::cend   (Foo::FakeContainer());
   (void) std::crbegin(Foo::FakeContainer());
-  (void) std::crend  (Foo::FakeContainer());  
+  (void) std::crend  (Foo::FakeContainer());
 }
 #endif

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp

 {
     const char* s = "1234567890";
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), true);
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1), false);
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);
-    
 #if TEST_STD_VER > 14
     {
         constexpr const char *p = "123456789";
         typedef std::reverse_iterator<const char *> RI;
         constexpr RI it1 = std::make_reverse_iterator(p);
         constexpr RI it2 = std::make_reverse_iterator(p);
         constexpr RI it3 = std::make_reverse_iterator(p+1);
         static_assert( (it1 == it2), "");
         static_assert(!(it1 == it3), "");
     }
 #endif
 
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd(false, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd(2, true);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd<volatile bool, int>(false, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd<int, const bool>(2, true);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd(2.0, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::gcd(4, 6.0);
 }

test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 #include <numeric>
 #include <cassert>

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm(false, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm(2, true);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm<volatile bool, int>(false, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm<int, const bool>(2, true);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm(2.0, 4);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
-// Remarks: If either M or N is not an integer type, 
+// Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
 
 int main()
 {
     std::lcm(4, 6.0);
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-// 
+//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 #include <numeric>
 #include <cassert>

test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class _Tp>
-//   basic_string(const _Tp& __t, size_type __pos, size_type __n, 
+//   basic_string(const _Tp& __t, size_type __pos, size_type __n,
 //                const allocator_type& __a = allocator_type());
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <string_view>
 #include <stdexcept>
 #include <algorithm>

test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
   }
 #endif
 
   { // test appending to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.append(s_short.begin(), s_short.end());
   assert(s_short == "123/123/");
   s_short.append(s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/");
   s_short.append(s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.append(s_long.begin(), s_long.end());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test appending a different type
     typedef std::string S;
   const uint8_t p[] = "ABCD";
 
   S s;
   s.append(p, p + 4);
   assert(s == "ABCD");
   }
 
 }

test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp

test(S("12345678901234567890"), "12345678901234567890",
          S("1234567890123456789012345678901234567890"));
     }
 #endif
 
   { // test appending to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.append(s_short.c_str());
   assert(s_short == "123/123/");
   s_short.append(s_short.c_str());
   assert(s_short == "123/123/123/123/");
   s_short.append(s_short.c_str());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.append(s_long.c_str());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp

test(S("12345678901234567890"), "12345678901234567890", 20,
          S("1234567890123456789012345678901234567890"));
     }
 #endif
 
   { // test appending to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.append(s_short.data(), s_short.size());
   assert(s_short == "123/123/");
   s_short.append(s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/");
   s_short.append(s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.append(s_long.data(), s_long.size());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
   }
 #endif
 
   { // test assigning to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.assign(s_short.begin(), s_short.end());
   assert(s_short == "123/");
   s_short.assign(s_short.begin() + 2, s_short.end());
   assert(s_short == "3/");
-  
   s_long.assign(s_long.begin(), s_long.end());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
   s_long.assign(s_long.begin() + 30, s_long.end());
   assert(s_long == "nsectetur/");
   }
 
   { // test assigning a different type
     typedef std::string S;
   const uint8_t p[] = "ABCD";
 
   S s;
   s.assign(p, p + 4);
   assert(s == "ABCD");
   }
 }

test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp

test(S("12345678901234567890"), "12345678901234567890",
          S("12345678901234567890"));
     }
 #endif
 
   { // test assignment to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.assign(s_short.c_str());
   assert(s_short == "123/");
   s_short.assign(s_short.c_str() + 2);
   assert(s_short == "3/");
-  
   s_long.assign(s_long.c_str() + 30);
   assert(s_long == "nsectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp

#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), "12345678901234567890", 20,
          S("12345678901234567890"));
     }
 #endif
   { // test assign to self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.assign(s_short.data(), s_short.size());
   assert(s_short == "123/");
   s_short.assign(s_short.data() + 2, s_short.size() - 2);
   assert(s_short == "3/");
-  
   s_long.assign(s_long.data(), s_long.size());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
   s_long.assign(s_long.data() + 2, 8 );
   assert(s_long == "rem ipsu");
   }
 }

test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

#if _LIBCPP_DEBUG >= 1
         assert(false);
     }
 #endif
 
   { // test inserting into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/");
   s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/");
   s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test assigning a different type
     typedef std::string S;
   const uint8_t p[] = "ABCD";
 
   S s;
   s.insert(s.begin(), p, p + 4);
   assert(s == "ABCD");
   }
 }

test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

#endif
 
     s.insert(0, "QRST", 0, std::string::npos); // calls insert(string("QRST"), pos, npos)
     assert(s == "QRST");
     s.clear();
 
     s.insert(0, sv, 0);  // calls insert(T, pos, npos)
     assert(s == sv);
     s.clear();
-    
     s.insert(0, sv, 0, std::string::npos);   // calls insert(T, pos, npos)
     assert(s == sv);
     s.clear();
 
     s.insert(0, arr, 0);     // calls insert(const char *, len)
     assert(s == "");
     s.clear();
 

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", S("can't happen"));
     }
 #endif
 
   { // test inserting into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.insert(0, s_short.c_str());
   assert(s_short == "123/123/");
   s_short.insert(0, s_short.c_str());
   assert(s_short == "123/123/123/123/");
   s_short.insert(0, s_short.c_str());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.insert(0, s_long.c_str());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

#if TEST_STD_VER >= 11
     test(S("abcdefghijklmnopqrst"), 21, "12345678901234567890", 20, S("can't happen"));
     }
 #endif
 
   { // test inserting into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.insert(0, s_short.data(), s_short.size());
   assert(s_short == "123/123/");
   s_short.insert(0, s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/");
   s_short.insert(0, s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.insert(0, s_long.data(), s_long.size());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
   }
 #endif
 
   { // test replacing into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test assigning a different type
     typedef std::string S;
   const uint8_t pc[] = "ABCD";
   uint8_t        p[] = "EFGH";

test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp

#if TEST_STD_VER >= 11
     test2<S>();
     }
 #endif
 
   { // test replacing into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
   assert(s_short == "123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
   assert(s_short == "123/123/123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

#if TEST_STD_VER >= 11
     test8<S>();
     }
 #endif
 
   { // test replacing into self
     typedef std::string S;
   S s_short = "123/";
   S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-  
   s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
   assert(s_short == "123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/");
   s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
   assert(s_short == "123/123/123/123/123/123/123/123/");
-  
   s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
   assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 }

test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template <class T>
-//    basic_string& replace(size_type pos1, size_type n1, const T& t, 
+//    basic_string& replace(size_type pos1, size_type n1, const T& t,
 //                          size_type pos2, size_type n=npos);
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>

test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
-                 
 #include <string>
 #include <cassert>
 
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)

test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp

 #if !defined(_WIN32) || defined(__MINGW32__)
     typedef unsigned ExpectUnsigned;
 #else
     typedef int ExpectUnsigned; // MSVC's ABI doesn't follow the Standard
 #endif
     static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
                   "E has the wrong underlying type");
     static_assert((std::is_same<std::underlying_type<F>::type, ExpectUnsigned>::value),
-                  "F has the wrong underlying type"); 
+                  "F has the wrong underlying type");
 
 #if TEST_STD_VER > 11
     static_assert((std::is_same<std::underlying_type_t<E>, int>::value), "");
-    static_assert((std::is_same<std::underlying_type_t<F>, ExpectUnsigned>::value), ""); 
+    static_assert((std::is_same<std::underlying_type_t<F>, ExpectUnsigned>::value), "");
 #endif
 
 #if TEST_STD_VER >= 11
     enum G : char { };
 
     static_assert((std::is_same<std::underlying_type<G>::type, char>::value),
                   "G has the wrong underlying type");
 #if TEST_STD_VER > 11
     static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
 #endif
 #endif // TEST_STD_VER >= 11
 }