Remove trailing whitespace in test suite. Approved by Marshall Clow.

llvm-svn: 271435

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp

@@ -21,7 +21,7 @@
 
 // ~dynarray();
 
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -43,7 +43,7 @@ void check_allocator ( const dynarray<T> &dyn, const Allocator &alloc ) {
 template <class T, class Allocator>
 void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals, alloc );
     assert ( d1.size () == vals.size() );
     assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
@@ -54,7 +54,7 @@ void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
 template <class T, class Allocator>
 void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4, alloc1 );
     assert ( d1.size () == 4 );
     assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } ));
@@ -67,16 +67,16 @@ void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
 
     dynA d3 ( d2, alloc2 );
     assert ( d3.size () == 7 );
-    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));   
+    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
     check_allocator ( d3, alloc2 );
     }
 
 int main()
 {
-//  This test is waiting on the resolution of LWG issue #2235 
+//  This test is waiting on the resolution of LWG issue #2235
 //     typedef test_allocator<char> Alloc;
 //     typedef std::basic_string<char, std::char_traits<char>, Alloc> nstr;
-// 
+//
 //     test ( nstr("fourteen"), Alloc(3), Alloc(4) );
 //     test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6));
 }

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp

@@ -35,7 +35,7 @@ using std::experimental::dynarray;
 template <class T>
 void testInitList( const std::initializer_list<T> &vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     assert ( d1.size () == vals.size() );
     assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
@@ -45,7 +45,7 @@ void testInitList( const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     assert ( d1.size () == 4 );
     if (!DefaultValueIsIndeterminate) {
@@ -58,7 +58,7 @@ void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
 
     dynA d3 ( d2 );
     assert ( d3.size () == 7 );
-    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));   
+    assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
     }
 
 void test_bad_length () {
@@ -76,12 +76,12 @@ int main()
     test<double> ( 14.0, true );
     test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
     test<std::string> ( "fourteen" );
-    
+
     testInitList( { 1, 1, 2, 3, 5, 8 } );
     testInitList( { 1., 1., 2., 3., 5., 8. } );
     testInitList( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                   std::string("5"), std::string("8")} );
-    
+
 //  Make sure we don't pick up the Allocator version here
     dynarray<long> d1 ( 20, 3 );
     assert ( d1.size() == 20 );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp

@@ -42,7 +42,7 @@ void dyn_test( dynarray<T> &dyn, bool CheckEquals = true) {
     }
 }
 
-    
+
 
 template <class T>
 void test(const T &val, bool DefaultValueIsIndeterminate = false) {
@@ -53,7 +53,7 @@ void test(const T &val, bool DefaultValueIsIndeterminate = false) {
     dynA d1(4);
     dyn_test(d1, CheckDefaultValues);
     dyn_test_const(d1, CheckDefaultValues);
-    
+
     dynA d2 (7, val);
     dyn_test ( d2 );
     dyn_test_const ( d2 );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp

@@ -13,7 +13,7 @@
 // void fill(const T& v);
 // const T* data() const noexcept;
 
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -28,11 +28,11 @@ using std::experimental::dynarray;
 template <class T>
 void test ( const T &val ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     d1.fill ( val );
-    assert ( std::all_of ( d1.begin (), d1.end (), 
+    assert ( std::all_of ( d1.begin (), d1.end (),
-                    [&val]( const T &item ){ return item == val; } ));  
+                    [&val]( const T &item ){ return item == val; } ));
     }
 
 int main()

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp

@@ -13,7 +13,7 @@
 
 // const_reference at(size_type n) const;
 //       reference at(size_type n);
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -72,7 +72,7 @@ void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals );
     dyn_test_const ( d1, vals );
@@ -82,7 +82,7 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp

@@ -17,7 +17,7 @@
 // iterator       end()          noexcept;
 // const_iterator end()    const noexcept;
 // const_iterator cend()   const noexcept;
-// 
+//
 // reverse_iterator       rbegin()        noexcept;
 // const_reverse_iterator rbegin()  const noexcept;
 // const_reverse_iterator crbegin() const noexcept;
@@ -25,7 +25,7 @@
 // const_reverse_iterator rend()    const noexcept;
 // const_reverse_iterator crend()   const noexcept;
 
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -85,11 +85,11 @@ void dyn_test ( dynarray<T> &dyn ) {
 template <class T>
 void test ( const T &val ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 4 );
     dyn_test ( d1 );
     dyn_test_const ( d1 );
-    
+
     dynA d2 ( 7, val );
     dyn_test ( d2 );
     dyn_test_const ( d2 );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp

@@ -12,7 +12,7 @@
 
 // size_type size()     const noexcept;
 // size_type max_size() const noexcept;
-// bool      empty()    const noexcept;  
+// bool      empty()    const noexcept;
 
 #include <__config>
 
@@ -35,7 +35,7 @@ void dyn_test ( const dynarray<T> &dyn, size_t sz ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals.size ());
     }
@@ -44,7 +44,7 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp

@@ -58,7 +58,7 @@ void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
     dynA d1 ( 4 );
     dyn_test ( d1, CheckDefaultValues );
     dyn_test_const ( d1, CheckDefaultValues );
-    
+
     dynA d2 ( 7, val );
     dyn_test ( d2 );
     dyn_test_const ( d2 );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp

@@ -12,7 +12,7 @@
 
 // const_reference at(size_type n) const;
 //       reference at(size_type n);
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -48,7 +48,7 @@ void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
 template <class T>
 void test ( std::initializer_list<T> vals ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( vals );
     dyn_test ( d1, vals );
     dyn_test_const ( d1, vals );
@@ -58,7 +58,7 @@ int main()
 {
     test ( { 1, 1, 2, 3, 5, 8 } );
     test ( { 1., 1., 2., 3., 5., 8. } );
-    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), 
+    test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
                 std::string("5"), std::string("8")} );
 
     test<int> ( {} );

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp

@@ -13,7 +13,7 @@
 // template <class Type, class Alloc>
 //   struct uses_allocator<dynarray<Type>, Alloc> : true_type { };
 
-  
+
 #include <__config>
 
 #include <experimental/dynarray>

libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp

@@ -11,12 +11,12 @@
 // dynarray.zero
 
 // dynarray shall provide support for the special case of construction with a size of zero.
-// In the case that the size is zero, begin() == end() == unique value. 
+// In the case that the size is zero, begin() == end() == unique value.
-// The return value of data() is unspecified. 
+// The return value of data() is unspecified.
 // The effect of calling front() or back() for a zero-sized dynarray is undefined.
 
 
-  
+
 #include <__config>
 
 #include <experimental/dynarray>
@@ -31,7 +31,7 @@ using std::experimental::dynarray;
 template <class T>
 void test ( ) {
     typedef dynarray<T> dynA;
-    
+
     dynA d1 ( 0 );
     assert ( d1.size() == 0 );
     assert ( d1.begin() == d1.end ());

libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp

@@ -13,7 +13,7 @@
 // __libcpp_is_trivial_iterator<Tp>
 
 // __libcpp_is_trivial_iterator determines if an iterator is a "trivial" one,
-// that can be used w/o worrying about its operations throwing exceptions. 
+// that can be used w/o worrying about its operations throwing exceptions.
 // Pointers are trivial iterators. Libc++ has three "iterator wrappers":
 // reverse_iterator, move_iterator, and __wrap_iter. If the underlying iterator
 // is trivial, then those are as well.
@@ -113,16 +113,16 @@ int main()
     static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<int *> >       ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::__wrap_iter<T *> >         ::value), "");
 
-    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), ""); 
+    static_assert(( std::__libcpp_is_trivial_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
-    
+
 //  iterators in the libc++ test suite
-    static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");    
+    static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");
 
 
 //	Iterator classification
@@ -137,7 +137,7 @@ int main()
 	static_assert((!std::__is_bidirectional_iterator<input_iterator<char *> >::value), "" );
 	static_assert((!std::__is_random_access_iterator<input_iterator<char *> >::value), "" );
 	static_assert(( std::__is_exactly_input_iterator<input_iterator<char *> >::value), "" );
-	
+
 	static_assert(( std::__is_input_iterator        <forward_iterator<char *> >::value), "" );
 	static_assert(( std::__is_forward_iterator      <forward_iterator<char *> >::value), "" );
 	static_assert((!std::__is_bidirectional_iterator<forward_iterator<char *> >::value), "" );
@@ -171,7 +171,7 @@ int main()
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_iterator>        ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::reverse_iterator>      ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::vector<char>::const_reverse_iterator>::value), "");
-    
+
 //  vector
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::const_iterator>        ::value), "");

libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp

@@ -31,17 +31,17 @@ int main()
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<const char *>::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<const char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
-    
+
 //  iterators in the libc++ test suite
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value), "");
@@ -49,7 +49,7 @@ int main()
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value), "");
     static_assert((!std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value), "");
-    
+
 #if TEST_STD_VER >= 11
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
 #else

libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp

@@ -34,17 +34,17 @@ int main()
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<const char *>::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::move_iterator<const char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<char *> >      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::__wrap_iter<const char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::reverse_iterator<std::__wrap_iter<char *> > > ::value), "");
-    
+
 //  iterators in the libc++ test suite
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value), "");
@@ -52,9 +52,9 @@ int main()
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value), "");
-    
+
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
-	
+
 //
 //  iterators from libc++'s containers
 //

libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp

@@ -11,7 +11,7 @@
 // __is_referenceable<Tp>
 //
 // [defns.referenceable] defines "a referenceable type" as:
-// An object type, a function type that does not have cv-qualifiers 
+// An object type, a function type that does not have cv-qualifiers
 //    or a ref-qualifier, or a reference type.
 //
 
@@ -44,7 +44,7 @@ static_assert(( std::__is_referenceable<const int   __attribute__((__vector_size
 static_assert(( std::__is_referenceable<float __attribute__((__vector_size__(16)))>::value), "");
 static_assert(( std::__is_referenceable<const float __attribute__((__vector_size__(16)))>::value), "");
 
-// Functions without cv-qualifiers are referenceable 
+// Functions without cv-qualifiers are referenceable
 static_assert(( std::__is_referenceable<void ()>::value), "");
 #if TEST_STD_VER >= 11
 static_assert((!std::__is_referenceable<void () const>::value), "");
@@ -117,7 +117,7 @@ static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) &&>::value
 static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const &&>::value), "");
 #endif
 
-// member functions with or without cv-qualifiers are referenceable 
+// member functions with or without cv-qualifiers are referenceable
 static_assert(( std::__is_referenceable<void (Foo::*)()>::value), "");
 static_assert(( std::__is_referenceable<void (Foo::*)() const>::value), "");
 #if TEST_STD_VER >= 11

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

@@ -62,7 +62,7 @@ test_int_array()
 
 struct source {
     source() : i(0) { }
-    
+
     operator int() const { return i++; }
     mutable int i;
 };

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

@@ -61,6 +61,6 @@ int main()
                        random_access_iterator<const int*>(ia+s),
                        random_access_iterator<const int*>(ia),
                        random_access_iterator<const int*>(ia+s-1)));
-    
+
 #endif
 }

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

@@ -33,7 +33,7 @@ int main()
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in c++11
-    
+
     typedef input_iterator<const int*> II;
     typedef random_access_iterator<const int*>  RAI;
     typedef std::equal_to<int> EQ;
@@ -48,7 +48,7 @@ int main()
             == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
     assert(bcp.count() > 0 && bcp.count() < sa);
     bcp.reset();
-        
+
 #ifdef HAS_FOUR_ITERATOR_VERSION
     assert(std::mismatch(II(ia), II(ia + sa), II(ib), II(ib + sb), EQ())
             == (std::pair<II, II>(II(ia+3), II(ib+3))));

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp

@@ -69,7 +69,7 @@ void test(unsigned N)
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N, std::ref(pred));
     assert(pred.count() <= 3*N);
-    assert(std::is_heap(ia, ia+N, pred));   
+    assert(std::is_heap(ia, ia+N, pred));
     }
 
     delete [] ia;

libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp

@@ -24,20 +24,20 @@
 struct S {
 	S() : i_(0) {}
 	S(int i) : i_(i) {}
-	
+
 	S(const S&  rhs) : i_(rhs.i_) {}
 	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
-	
+
 	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
 	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
 	S& operator =(int i)         { i_ = i;                   return *this; }
-	
+
 	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
 	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
 	bool operator ==(int i)         const { return i_ == i; }
 
 	void set(int i) { i_ = i; }
-	
+
 	int i_;
 	};
 #endif

libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp

@@ -34,21 +34,21 @@ struct indirect_less
 struct S {
 	S() : i_(0) {}
 	S(int i) : i_(i) {}
-	
+
 	S(const S&  rhs) : i_(rhs.i_) {}
 	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
-	
+
 	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
 	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
 	S& operator =(int i)         { i_ = i;                   return *this; }
-	
+
 	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
 	bool operator  >(const S&  rhs) const { return i_ > rhs.i_; }
 	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
 	bool operator ==(int i)         const { return i_ == i; }
 
 	void set(int i) { i_ = i; }
-	
+
 	int i_;
 	};
 

libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp

@@ -75,6 +75,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
     constexpr_test ();
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp

@@ -95,6 +95,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
-    
+
     constexpr_test();
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp

@@ -95,6 +95,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
-    
+
     constexpr_test();
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp

@@ -47,7 +47,7 @@ int main()
     }
 #if _LIBCPP_STD_VER > 11
     {
-//  Note that you can't take a reference to a local var, since 
+//  Note that you can't take a reference to a local var, since
 //  its address is not a compile-time constant.
     constexpr static int x = 1;
     constexpr static int y = 0;

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp

@@ -50,7 +50,7 @@ int main()
     }
 #if _LIBCPP_STD_VER > 11
     {
-//  Note that you can't take a reference to a local var, since 
+//  Note that you can't take a reference to a local var, since
 //  its address is not a compile-time constant.
     constexpr static int x = 1;
     constexpr static int y = 0;

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp

@@ -93,6 +93,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
    constexpr_test();
 }

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp

@@ -99,6 +99,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
-    
+
     constexpr_test();
 }

libcxx/test/std/atomics/atomics.types.generic/address.pass.cpp

@@ -45,13 +45,13 @@
 //     T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst);
 //     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile;
 //     T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(T* desr);
 //     atomic(const atomic&) = delete;
 //     atomic& operator=(const atomic&) = delete;
 //     atomic& operator=(const atomic&) volatile = delete;
-// 
+//
 //     T* operator=(T*) volatile;
 //     T* operator=(T*);
 //     T* operator++(int) volatile;
@@ -122,7 +122,7 @@ do_test()
 
     {
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
-        A& zero = *new (storage) A();    
+        A& zero = *new (storage) A();
         assert(zero == 0);
         zero.~A();
     }

libcxx/test/std/atomics/atomics.types.generic/bool.pass.cpp

@@ -39,7 +39,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(T desr);
 //     atomic(const atomic&) = delete;
@@ -227,7 +227,7 @@ int main()
     {
         typedef std::atomic<bool> A;
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1};
-        A& zero = *new (storage) A();    
+        A& zero = *new (storage) A();
         assert(zero == false);
         zero.~A();
     }

libcxx/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp

@@ -19,7 +19,7 @@
 // typedef atomic<uint_least32_t> atomic_uint_least32_t;
 // typedef atomic<int_least64_t>  atomic_int_least64_t;
 // typedef atomic<uint_least64_t> atomic_uint_least64_t;
-// 
+//
 // typedef atomic<int_fast8_t>   atomic_int_fast8_t;
 // typedef atomic<uint_fast8_t>  atomic_uint_fast8_t;
 // typedef atomic<int_fast16_t>  atomic_int_fast16_t;
@@ -28,7 +28,7 @@
 // typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
 // typedef atomic<int_fast64_t>  atomic_int_fast64_t;
 // typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
-// 
+//
 // typedef atomic<intptr_t>  atomic_intptr_t;
 // typedef atomic<uintptr_t> atomic_uintptr_t;
 // typedef atomic<size_t>    atomic_size_t;

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

@@ -41,7 +41,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile;
 //     bool compare_exchange_strong(integral& expc, integral desr,
 //                                  memory_order m = memory_order_seq_cst);
-// 
+//
 //     integral
 //         fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile;
 //     integral fetch_add(integral op, memory_order m = memory_order_seq_cst);
@@ -57,7 +57,7 @@
 //     integral
 //         fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile;
 //     integral fetch_xor(integral op, memory_order m = memory_order_seq_cst);
-// 
+//
 //     atomic() = default;
 //     constexpr atomic(integral desr);
 //     atomic(const atomic&) = delete;
@@ -65,7 +65,7 @@
 //     atomic& operator=(const atomic&) volatile = delete;
 //     integral operator=(integral desr) volatile;
 //     integral operator=(integral desr);
-// 
+//
 //     integral operator++(int) volatile;
 //     integral operator++(int);
 //     integral operator--(int) volatile;
@@ -152,7 +152,7 @@ do_test()
 
     {
         _ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
-        A& zero = *new (storage) A();    
+        A& zero = *new (storage) A();
         assert(zero == 0);
         zero.~A();
     }

libcxx/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp

@@ -37,7 +37,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) noexcept;
-// 
+//
 //     atomic() noexcept = default;
 //     constexpr atomic(T desr) noexcept;
 //     atomic(const atomic&) = delete;

libcxx/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp

@@ -43,7 +43,7 @@
 //                                 memory_order m = memory_order_seq_cst) volatile noexcept;
 //     bool compare_exchange_strong(T& expc, T desr,
 //                                  memory_order m = memory_order_seq_cst) noexcept;
-// 
+//
 //     atomic() noexcept = default;
 //     constexpr atomic(T desr) noexcept;
 //     atomic(const atomic&) = delete;

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

@@ -17,7 +17,7 @@
 //     atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, T* expc,
 //                                           T desr,
 //                                           memory_order s, memory_order f);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

@@ -17,7 +17,7 @@
 //     atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
 //                                           T desr,
 //                                           memory_order s, memory_order f);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_exchange(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     T
 //     atomic_exchange(atomic<T>* obj, T desr);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-// 
+//
 // template <class T>
 //     T
 //     atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

@@ -15,15 +15,15 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_add(atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

@@ -15,15 +15,15 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_sub(atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

@@ -20,7 +20,7 @@
 //     Integral
 //     atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
 //                               memory_order m);
-// 
+//
 // template <class T>
 //     T*
 //     atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp

@@ -14,7 +14,7 @@
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op);
-// 
+//
 // template <class Integral>
 //     Integral
 //     atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h

@@ -24,10 +24,10 @@ struct UserAtomicType
     { return x.i == y.i; }
 };
 
-template < template <class TestArg> class TestFunctor > 
+template < template <class TestArg> class TestFunctor >
 struct TestEachIntegralType {
     void operator()() const {
-        TestFunctor<char>()(); 
+        TestFunctor<char>()();
         TestFunctor<signed char>()();
         TestFunctor<unsigned char>()();
         TestFunctor<short>()();
@@ -46,7 +46,7 @@ struct TestEachIntegralType {
     }
 };
 
-template < template <class TestArg> class TestFunctor > 
+template < template <class TestArg> class TestFunctor >
 struct TestEachAtomicType {
     void operator()() const {
         TestEachIntegralType<TestFunctor>()();

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     void
 //     atomic_init(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     void
 //     atomic_init(atomic<T>* obj, T desr);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp

@@ -14,7 +14,7 @@
 // template <class T>
 //     bool
 //     atomic_is_lock_free(const volatile atomic<T>* obj);
-// 
+//
 // template <class T>
 //     bool
 //     atomic_is_lock_free(const atomic<T>* obj);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_load(const volatile atomic<T>* obj);
-// 
+//
 // template <class T>
 //     T
 //     atomic_load(const atomic<T>* obj);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

@@ -15,7 +15,7 @@
 // template <class T>
 //     T
 //     atomic_load_explicit(const volatile atomic<T>* obj, memory_order m);
-// 
+//
 // template <class T>
 //     T
 //     atomic_load_explicit(const atomic<T>* obj, memory_order m);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

@@ -14,7 +14,7 @@
 // template <class T>
 //     void
 //     atomic_store(volatile atomic<T>* obj, T desr);
-// 
+//
 // template <class T>
 //     void
 //     atomic_store(atomic<T>* obj, T desr);

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

@@ -14,7 +14,7 @@
 // template <class T>
 //     void
 //     atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-// 
+//
 // template <class T>
 //     void
 //     atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);

libcxx/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

@@ -169,7 +169,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == num+3);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == num+6);
@@ -187,7 +187,7 @@ int main()
             }
             assert(Counter_base::gConstructed == num+3);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
 #if __cplusplus >= 201103L
     {

libcxx/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp

@@ -64,7 +64,7 @@ int main()
         assert(m.size() == 1);
         assert(m.begin()->first == 2);
         assert(m.begin()->second == Emplaceable());
-        r = m.emplace_hint(m.end(), std::piecewise_construct, 
+        r = m.emplace_hint(m.end(), std::piecewise_construct,
                                     std::forward_as_tuple(1),
                                     std::forward_as_tuple(2, 3.5));
         assert(r == m.begin());
@@ -130,7 +130,7 @@ int main()
         assert(m.size() == 1);
         assert(m.begin()->first == 2);
         assert(m.begin()->second == Emplaceable());
-        r = m.emplace_hint(m.end(), std::piecewise_construct, 
+        r = m.emplace_hint(m.end(), std::piecewise_construct,
                                     std::forward_as_tuple(1),
                                     std::forward_as_tuple(2, 3.5));
         assert(r == m.begin());

libcxx/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp

@@ -100,7 +100,7 @@ int main()
         assert(r.first->second.get() == -1); // value
     }
 
-    {  // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); 
+    {  // pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
         typedef std::map<Moveable, Moveable> M;
         typedef std::pair<M::iterator, bool> R;
         M m;
@@ -136,7 +136,7 @@ int main()
             m.try_emplace ( i, Moveable(i, (double) i));
         assert(m.size() == 10);
         M::const_iterator it = m.find(2);
-        
+
         Moveable mv1(3, 3.0);
         for (int i=0; i < 20; i += 2)
         {

libcxx/test/std/containers/associative/map/map.ops/count0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/count1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/count2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/count3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/find0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/find1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/find2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/find3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp

@@ -317,7 +317,7 @@ int main()
     r = m.lower_bound(C2Int(20));
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor PC;
     typedef std::map<PC, double, std::less<>> M;

libcxx/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp

@@ -280,7 +280,7 @@ int main()
     r = m.upper_bound(20);
     assert(r == next(m.begin(), 8));
     }
-    
+
     {
     typedef PrivateConstructor PC;
     typedef std::map<PC, double, std::less<>> M;

libcxx/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp

@@ -17,7 +17,7 @@
 //
 //  In C++17, the standard says that swap shall have:
 //     noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));                 
+//              noexcept(swap(declval<Compare&>(), declval<Compare&>())));
 
 // This tests a conforming extension
 
@@ -32,7 +32,7 @@ template <class T>
 struct some_comp
 {
     typedef T value_type;
-    
+
     some_comp() {}
     some_comp(const some_comp&) {}
     void deallocate(void*, unsigned) {}
@@ -44,7 +44,7 @@ template <class T>
 struct some_comp2
 {
     typedef T value_type;
-    
+
     some_comp2() {}
     some_comp2(const some_comp2&) {}
     void deallocate(void*, unsigned) {}
@@ -60,7 +60,7 @@ template <class T>
 struct some_alloc
 {
     typedef T value_type;
-    
+
     some_alloc() {}
     some_alloc(const some_alloc&);
     void deallocate(void*, unsigned) {}
@@ -72,7 +72,7 @@ template <class T>
 struct some_alloc2
 {
     typedef T value_type;
-    
+
     some_alloc2() {}
     some_alloc2(const some_alloc2&);
     void deallocate(void*, unsigned) {}
@@ -85,7 +85,7 @@ template <class T>
 struct some_alloc3
 {
     typedef T value_type;
-    
+
     some_alloc3() {}
     some_alloc3(const some_alloc3&);
     void deallocate(void*, unsigned) {}

libcxx/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp

@@ -169,7 +169,7 @@ int main()
 
             M m1(I(a1), I(a1+num), C(), A());
             assert(Counter_base::gConstructed == 2*num);
-        
+
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 3*num);
@@ -187,7 +187,7 @@ int main()
             }
             assert(Counter_base::gConstructed == 2*num);
         }
-        assert(Counter_base::gConstructed == 0);            
+        assert(Counter_base::gConstructed == 0);
     }
 #if __cplusplus >= 201103L
     {

libcxx/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator find(const key_type& k);
 // const_iterator find(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp

@@ -13,9 +13,9 @@
 
 //       iterator lower_bound(const key_type& k);
 // const_iterator lower_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type
 
 

libcxx/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp

@@ -15,9 +15,9 @@
 
 //       iterator upper_bound(const key_type& k);
 // const_iterator upper_bound(const key_type& k) const;
-// 
+//
-//   The member function templates find, count, lower_bound, upper_bound, and 
+//   The member function templates find, count, lower_bound, upper_bound, and
-// equal_range shall not participate in overload resolution unless the 
+// equal_range shall not participate in overload resolution unless the
 // qualified-id Compare::is_transparent is valid and denotes a type