Fixing whitespace problems

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111753 91177308-0d34-0410-b5e6-96231b3b80d8

test/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires HasLess<T, Iter::value_type> 
-//         && HasLess<Iter::value_type, T> 
+// template<ForwardIterator Iter, class T>
+//   requires HasLess<T, Iter::value_type>
+//         && HasLess<Iter::value_type, T>
 //   bool
 //   binary_search(Iter first, Iter last, const T& value);
 

test/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T, CopyConstructible Compare> 
-//   requires Predicate<Compare, T, Iter::value_type> 
-//         && Predicate<Compare, Iter::value_type, T> 
+// template<ForwardIterator Iter, class T, CopyConstructible Compare>
+//   requires Predicate<Compare, T, Iter::value_type>
+//         && Predicate<Compare, Iter::value_type, T>
 //   bool
 //   binary_search(Iter first, Iter last, const T& value, Compare comp);
 

test/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires HasLess<T, Iter::value_type> 
-//         && HasLess<Iter::value_type, T> 
-//   pair<Iter, Iter> 
+// template<ForwardIterator Iter, class T>
+//   requires HasLess<T, Iter::value_type>
+//         && HasLess<Iter::value_type, T>
+//   pair<Iter, Iter>
 //   equal_range(Iter first, Iter last, const T& value);
 
 #include <algorithm>

test/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T, CopyConstructible Compare> 
-//   requires Predicate<Compare, T, Iter::value_type> 
-//         && Predicate<Compare, Iter::value_type, T> 
-//   pair<Iter, Iter> 
+// template<ForwardIterator Iter, class T, CopyConstructible Compare>
+//   requires Predicate<Compare, T, Iter::value_type>
+//         && Predicate<Compare, Iter::value_type, T>
+//   pair<Iter, Iter>
 //   equal_range(Iter first, Iter last, const T& value, Compare comp);
 
 #include <algorithm>

test/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires HasLess<Iter::value_type, T> 
+// template<ForwardIterator Iter, class T>
+//   requires HasLess<Iter::value_type, T>
 //   Iter
 //   lower_bound(Iter first, Iter last, const T& value);
 

test/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires HasLess<Iter::value_type, T> 
+// template<ForwardIterator Iter, class T>
+//   requires HasLess<Iter::value_type, T>
 //   Iter
 //   lower_bound(Iter first, Iter last, const T& value);
 

test/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires HasLess<T, Iter::value_type> 
+// template<ForwardIterator Iter, class T>
+//   requires HasLess<T, Iter::value_type>
 //   Iter
 //   upper_bound(Iter first, Iter last, const T& value);
 

test/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   Iter
 //   upper_bound(Iter first, Iter last, const T& value, Compare comp);
 

test/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp

@@ -9,15 +9,14 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   bool
 //   is_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-
 void test()
 {
     int i1[] = {0, 0};

test/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   bool
 //   is_heap(Iter first, Iter last);
 
@@ -18,7 +18,6 @@
 #include <functional>
 #include <cassert>
 
-
 void test()
 {
     int i1[] = {0, 0};

test/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp

@@ -17,7 +17,6 @@
 #include <algorithm>
 #include <cassert>
 
-
 void test()
 {
     int i1[] = {0, 0};

test/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   Iter
 //   is_heap_until(Iter first, Iter last, Compare comp);
 

test/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp

@@ -9,15 +9,14 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   make_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-
 void test(unsigned N)
 {
     int* ia = new int [N];

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
 //   void
 //   make_heap(Iter first, Iter last, Compare comp);
 
@@ -27,7 +27,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void test(unsigned N)
 {
@@ -60,5 +60,5 @@ int main()
     assert(std::is_heap(ia, ia+N, indirect_less()));
     delete [] ia;
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp

@@ -9,15 +9,14 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   pop_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-
 void test(unsigned N)
 {
     int* ia = new int [N];

test/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
 //   void
 //   pop_heap(Iter first, Iter last, Compare comp);
 
@@ -27,7 +27,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void test(unsigned N)
 {
@@ -64,5 +64,5 @@ int main()
     }
     delete [] ia;
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp

@@ -9,16 +9,15 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   push_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-
 void test(unsigned N)
 {
     int* ia = new int [N];

test/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   push_heap(Iter first, Iter last);
 
@@ -28,7 +28,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void test(unsigned N)
 {
@@ -62,5 +62,5 @@ int main()
     }
     delete [] ia;
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp

@@ -9,15 +9,14 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   sort_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-
 void test(unsigned N)
 {
     int* ia = new int [N];

test/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
 //   void
 //   sort_heap(Iter first, Iter last, Compare comp);
 
@@ -27,7 +27,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void test(unsigned N)
 {
@@ -62,5 +62,5 @@ int main()
     assert(std::is_sorted(ia, ia+N, indirect_less()));
     delete [] ia;
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2> 
-//   requires HasLess<Iter1::value_type, Iter2::value_type> 
-//         && HasLess<Iter2::value_type, Iter1::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2>
+//   requires HasLess<Iter1::value_type, Iter2::value_type>
+//         && HasLess<Iter2::value_type, Iter1::value_type>
 //   bool
 //   lexicographical_compare(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 

test/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2, CopyConstructible Compare> 
-//   requires Predicate<Compare, Iter1::value_type, Iter2::value_type> 
-//         && Predicate<Compare, Iter2::value_type, Iter1::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2, CopyConstructible Compare>
+//   requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
+//         && Predicate<Compare, Iter2::value_type, Iter1::value_type>
 //   bool
 //   lexicographical_compare(Iter1 first1, Iter1 last1,
 //                           Iter2 first2, Iter2 last2, Compare comp);

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

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<BidirectionalIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   inplace_merge(Iter first, Iter middle, Iter last);
 

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

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   void
 //   inplace_merge(Iter first, Iter middle, Iter last, Compare comp);
 
@@ -28,7 +28,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 #include "../../iterators.h"
 
@@ -108,5 +108,5 @@ int main()
     }
     delete [] ia;
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.merge/merge.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && HasLess<InIter2::value_type, InIter1::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && HasLess<InIter2::value_type, InIter1::value_type>
 //   OutIter
 //   merge(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2, OutIter result);
 

test/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter, 
-//          Predicate<auto, InIter2::value_type, InIter1::value_type> Compare> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
+//          Predicate<auto, InIter2::value_type, InIter1::value_type> Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && CopyConstructible<Compare> 
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && CopyConstructible<Compare>
 //   OutIter
 //   merge(InIter1 first1, InIter1 last1,
 //         InIter2 first2, InIter2 last2, OutIter result, Compare comp);

test/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<class T, StrictWeakOrder<auto, T> Compare> 
-//   requires !SameType<T, Compare> && CopyConstructible<Compare> 
+// template<class T, StrictWeakOrder<auto, T> Compare>
+//   requires !SameType<T, Compare> && CopyConstructible<Compare>
 //   const T&
 //   max(const T& a, const T& b, Compare comp);
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<ForwardIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   Iter
 //   max_element(Iter first, Iter last);
 
@@ -41,7 +41,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   Iter
 //   max_element(Iter first, Iter last, Compare comp);
 
@@ -42,7 +42,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template <class T> 
+// template <class T>
 //   T
 //   max(initializer_list<T> t);
 
@@ -31,5 +31,5 @@ int main()
     assert(i == 3);
     i = std::max({1, 3, 2});
     assert(i == 3);
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<class T, class Compare> 
+// template<class T, class Compare>
 //   T
 //   max(initializer_list<T> t, Compare comp);
 
@@ -32,5 +32,5 @@ int main()
     assert(i == 1);
     i = std::max({1, 3, 2}, std::greater<int>());
     assert(i == 1);
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<class T, StrictWeakOrder<auto, T> Compare> 
-//   requires !SameType<T, Compare> && CopyConstructible<Compare> 
+// template<class T, StrictWeakOrder<auto, T> Compare>
+//   requires !SameType<T, Compare> && CopyConstructible<Compare>
 //   const T&
 //   min(const T& a, const T& b, Compare comp);
 

test/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<ForwardIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   Iter
 //   min_element(Iter first, Iter last);
 
@@ -41,7 +41,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   Iter
 //   min_element(Iter first, Iter last, Compare comp);
 
@@ -42,7 +42,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<class T> 
+// template<class T>
 //   T
 //   min(initializer_list<T> t);
 
@@ -31,5 +31,5 @@ int main()
     assert(i == 1);
     i = std::min({1, 3, 2});
     assert(i == 1);
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<class T, class Compare> 
+// template<class T, class Compare>
 //   T
 //   min(initializer_list<T> t, Compare comp);
 
@@ -32,5 +32,5 @@ int main()
     assert(i == 3);
     i = std::min({1, 3, 2}, std::greater<int>());
     assert(i == 3);
-#endif
+#endif  // _LIBCPP_MOVE
 }

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<class T, StrictWeakOrder<auto, T> Compare> 
-//   requires !SameType<T, Compare> && CopyConstructible<Compare> 
+// template<class T, StrictWeakOrder<auto, T> Compare>
+//   requires !SameType<T, Compare> && CopyConstructible<Compare>
 //   pair<const T&, const T&>
 //   minmax(const T& a, const T& b, Compare comp);
 

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

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
-//   pair<Iter, Iter> 
+// template<ForwardIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
+//   pair<Iter, Iter>
 //   minmax_element(Iter first, Iter last);
 
 #include <algorithm>
@@ -47,7 +47,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   pair<Iter, Iter>
 //   minmax_element(Iter first, Iter last, Compare comp);
 
@@ -50,7 +50,7 @@ test(unsigned N)
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
-    test(Iter(a), Iter(a+N)); 
+    test(Iter(a), Iter(a+N));
     delete [] a;
 }
 

test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<class T> 
+// template<class T>
 //   pair<T, T>
 //   minmax(initializer_list<T> t);
 
@@ -25,5 +25,5 @@ int main()
     assert((std::minmax({2, 3, 1}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({3, 1, 2}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)));
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<class T, class Compare> 
+// template<class T, class Compare>
 //   pair<T, T>
 //   minmax(initializer_list<T> t, Compare comp);
 
@@ -26,5 +26,5 @@ int main()
     assert((std::minmax({2, 3, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({3, 1, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   nth_element(Iter first, Iter nth, Iter last);
 

test/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   void
 //   nth_element(Iter first, Iter nth, Iter last, Compare comp);
 
@@ -29,7 +29,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void
 test_one(unsigned N, unsigned M)
@@ -81,5 +81,5 @@ int main()
     std::nth_element(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
     assert(*v[v.size()/2] == v.size()/2);
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter> 
+// template<BidirectionalIterator Iter>
 //   requires ShuffleIterator<Iter>
-//         && LessThanComparable<Iter::value_type> 
+//         && LessThanComparable<Iter::value_type>
 //   bool
 //   next_permutation(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   bool
 //   next_permutation(Iter first, Iter last, Compare comp);
 

test/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<BidirectionalIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   bool
 //   prev_permutation(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   bool
 //   prev_permutation(Iter first, Iter last, Compare comp);
 

test/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2> 
-//   requires HasLess<Iter1::value_type, Iter2::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2>
+//   requires HasLess<Iter1::value_type, Iter2::value_type>
 //         && HasLess<Iter2::value_type, Iter1::value_type>
 //   bool
 //   includes(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
@@ -41,7 +41,6 @@ test()
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb)));
     assert(!std::includes(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa)));
 
-
     assert(std::includes(Iter1(ia), Iter1(ia+2), Iter2(ic), Iter2(ic+2)));
     assert(!std::includes(Iter1(ia), Iter1(ia+2), Iter2(ib), Iter2(ib+2)));
 

test/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2, typename Compare> 
-//   requires Predicate<Compare, Iter1::value_type, Iter2::value_type> 
-//         && Predicate<Compare, Iter2::value_type, Iter1::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2, typename Compare>
+//   requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
+//         && Predicate<Compare, Iter2::value_type, Iter1::value_type>
 //   bool
 //   includes(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Compare comp);
 
@@ -42,7 +42,6 @@ test()
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb), std::less<int>()));
     assert(!std::includes(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa), std::less<int>()));
 
-
     assert(std::includes(Iter1(ia), Iter1(ia+2), Iter2(ic), Iter2(ic+2), std::less<int>()));
     assert(!std::includes(Iter1(ia), Iter1(ia+2), Iter2(ib), Iter2(ib+2), std::less<int>()));
 

test/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && HasLess<InIter2::value_type, InIter1::value_type> 
-//         && HasLess<InIter1::value_type, InIter2::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && HasLess<InIter2::value_type, InIter1::value_type>
+//         && HasLess<InIter1::value_type, InIter2::value_type>
 //   OutIter
 //   set_difference(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
 //                  OutIter result);

test/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

@@ -9,12 +9,12 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter, 
-//          CopyConstructible Compare> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && Predicate<Compare, InIter1::value_type, InIter2::value_type> 
-//         && Predicate<Compare, InIter2::value_type, InIter1::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
+//          CopyConstructible Compare>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
+//         && Predicate<Compare, InIter2::value_type, InIter1::value_type>
 //   OutIter
 //   set_difference(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
 //                  OutIter result, Compare comp);

test/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && HasLess<InIter2::value_type, InIter1::value_type> 
-//         && HasLess<InIter1::value_type, InIter2::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && HasLess<InIter2::value_type, InIter1::value_type>
+//         && HasLess<InIter1::value_type, InIter2::value_type>
 //   OutIter
 //   set_intersection(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
 //                    OutIter result);

test/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp

@@ -9,12 +9,12 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter, 
-//          CopyConstructible Compare> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && Predicate<Compare, InIter1::value_type, InIter2::value_type> 
-//         && Predicate<Compare, InIter2::value_type, InIter1::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
+//          CopyConstructible Compare>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
+//         && Predicate<Compare, InIter2::value_type, InIter1::value_type>
 //   OutIter
 //   set_intersection(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
 //                    OutIter result, Compare comp);

test/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && HasLess<InIter2::value_type, InIter1::value_type> 
-//         && HasLess<InIter1::value_type, InIter2::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && HasLess<InIter2::value_type, InIter1::value_type>
+//         && HasLess<InIter1::value_type, InIter2::value_type>
 //   OutIter
 //   set_symmetric_difference(InIter1 first1, InIter1 last1,
 //                            InIter2 first2, InIter2 last2,

test/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

@@ -10,14 +10,14 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && Predicate<Compare, InIter1::value_type, InIter2::value_type> 
-//         && Predicate<Compare, InIter2::value_type, InIter1::value_type> 
+//          CopyConstructible Compare>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
+//         && Predicate<Compare, InIter2::value_type, InIter1::value_type>
 //   OutIter
 //   set_symmetric_difference(InIter1 first1, InIter1 last1,
-//                            InIter2 first2, InIter2 last2, 
+//                            InIter2 first2, InIter2 last2,
 //                            OutIter result, Compare comp);
 
 #include <algorithm>

test/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, typename OutIter> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && HasLess<InIter2::value_type, InIter1::value_type> 
-//         && HasLess<InIter1::value_type, InIter2::value_type> 
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && HasLess<InIter2::value_type, InIter1::value_type>
+//         && HasLess<InIter1::value_type, InIter2::value_type>
 //   OutIter
 //   set_union(InIter1 first1, InIter1 last1,
 //             InIter2 first2, InIter2 last2, OutIter result);

test/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

@@ -10,11 +10,11 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare> 
-//   requires OutputIterator<OutIter, InIter1::reference> 
-//         && OutputIterator<OutIter, InIter2::reference> 
-//         && Predicate<Compare, InIter1::value_type, InIter2::value_type> 
-//         && Predicate<Compare, InIter2::value_type, InIter1::value_type> 
+//          CopyConstructible Compare>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
+//         && Predicate<Compare, InIter2::value_type, InIter1::value_type>
 //   OutIter
 //   set_union(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
 //             OutIter result, Compare comp);

test/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<ForwardIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   bool
 //   is_sorted(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   bool
 //   is_sorted(Iter first, Iter last, Compare comp);
 

test/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
-//   requires LessThanComparable<Iter::value_type> 
+// template<ForwardIterator Iter>
+//   requires LessThanComparable<Iter::value_type>
 //   Iter
 //   is_sorted_until(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires CopyConstructible<Compare> 
+// template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires CopyConstructible<Compare>
 //   Iter
 //   is_sorted_until(Iter first, Iter last, Compare comp);
 

test/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, RandomAccessIterator RAIter> 
-//   requires ShuffleIterator<RAIter> 
-//         && OutputIterator<RAIter, InIter::reference> 
-//         && HasLess<InIter::value_type, RAIter::value_type> 
-//         && LessThanComparable<RAIter::value_type> 
+// template<InputIterator InIter, RandomAccessIterator RAIter>
+//   requires ShuffleIterator<RAIter>
+//         && OutputIterator<RAIter, InIter::reference>
+//         && HasLess<InIter::value_type, RAIter::value_type>
+//         && LessThanComparable<RAIter::value_type>
 //   RAIter
 //   partial_sort_copy(InIter first, InIter last, RAIter result_first, RAIter result_last);
 

test/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp

@@ -9,12 +9,12 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, RandomAccessIterator RAIter, class Compare> 
-//   requires ShuffleIterator<RAIter> 
-//         && OutputIterator<RAIter, InIter::reference> 
-//         && Predicate<Compare, InIter::value_type, RAIter::value_type> 
-//         && StrictWeakOrder<Compare, RAIter::value_type>} 
-//         && CopyConstructible<Compare> 
+// template<InputIterator InIter, RandomAccessIterator RAIter, class Compare>
+//   requires ShuffleIterator<RAIter>
+//         && OutputIterator<RAIter, InIter::reference>
+//         && Predicate<Compare, InIter::value_type, RAIter::value_type>
+//         && StrictWeakOrder<Compare, RAIter::value_type>}
+//         && CopyConstructible<Compare>
 //   RAIter
 //   partial_sort_copy(InIter first, InIter last,
 //                     RAIter result_first, RAIter result_last, Compare comp);

test/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   partial_sort(Iter first, Iter middle, Iter last);
 

test/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   void
 //   partial_sort(Iter first, Iter middle, Iter last, Compare comp);
 
@@ -29,7 +29,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 void
 test_larger_sorts(unsigned N, unsigned M)
@@ -83,5 +83,5 @@ int main()
     for (int i = 0; i < v.size()/2; ++i)
         assert(*v[i] == i);
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   sort(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   void
 //   sort(Iter first, Iter last, Compare comp);
 
@@ -29,8 +29,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
-
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -54,5 +53,5 @@ int main()
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
-//         && LessThanComparable<Iter::value_type> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
+//         && LessThanComparable<Iter::value_type>
 //   void
 //   stable_sort(Iter first, Iter last);
 

test/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Compare> 
+// template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Compare>
 //   void
 //   stable_sort(Iter first, Iter last, Compare comp);
 
@@ -29,7 +29,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 struct first_only
 {
@@ -79,5 +79,5 @@ int main()
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
-#endif
+#endif  // _LIBCPP_MOVE
 }