Fixing whitespace problems

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

test/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter> 
+// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   OutIter
 //   copy(InIter first, InIter last, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator InIter, BidirectionalIterator OutIter> 
-//   requires OutputIterator<OutIter, InIter::reference> 
+// template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
+//   requires OutputIterator<OutIter, InIter::reference>
 //   OutIter
 //   copy_backward(InIter first, InIter last, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter, 
-//          Predicate<auto, InIter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter,
+//          Predicate<auto, InIter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   OutIter
 //   copy_if(InIter first, InIter last, OutIter result, Pred pred);
 

test/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter> 
+// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   OutIter
 //   copy_n(InIter first, InIter::difference_type n, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires OutputIterator<Iter, const T&> 
+// template<ForwardIterator Iter, class T>
+//   requires OutputIterator<Iter, const T&>
 //   void
 //   fill(Iter first, Iter last, const T& value);
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<class Iter, IntegralLike Size, class T> 
-//   requires OutputIterator<Iter, const T&> 
+// template<class Iter, IntegralLike Size, class T>
+//   requires OutputIterator<Iter, const T&>
 //   OutputIterator
 //   fill_n(Iter first, Size n, const T& value);
 

test/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, Callable Generator> 
-//   requires OutputIterator<Iter, Generator::result_type> 
-//         && CopyConstructible<Generator> 
+// template<ForwardIterator Iter, Callable Generator>
+//   requires OutputIterator<Iter, Generator::result_type>
+//         && CopyConstructible<Generator>
 //   void
 //   generate(Iter first, Iter last, Generator gen);
 

test/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp

@@ -10,8 +10,8 @@
 // <algorithm>
 
 // template<class Iter, IntegralLike Size, Callable Generator>
-//   requires OutputIterator<Iter, Generator::result_type> 
-//         && CopyConstructible<Generator> 
+//   requires OutputIterator<Iter, Generator::result_type>
+//         && CopyConstructible<Generator>
 //   void
 //   generate_n(Iter first, Size n, Generator gen);
 

test/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, typename OutIter> 
-//   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type> 
+// template<InputIterator InIter, typename OutIter>
+//   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move(InIter first, InIter last, OutIter result);
 
@@ -56,7 +56,7 @@ test1()
         assert(*ib[i] == i);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -130,5 +130,5 @@ int main()
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator InIter, BidirectionalIterator OutIter> 
-//   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type> 
+// template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
+//   requires OutputIterator<OutIter, RvalueOf<InIter::reference>::type>
 //   OutIter
 //   move_backward(InIter first, InIter last, OutIter result);
 
@@ -56,7 +56,7 @@ test1()
         assert(*ib[i] == i);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -84,5 +84,5 @@ int main()
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

@@ -13,7 +13,6 @@
 //     bool
 //     is_partitioned(InputIterator first, InputIterator last, Predicate pred);
 
-
 #include <algorithm>
 #include <cassert>
 

test/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Pred> 
+// template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Pred>
 //   Iter
 //   partition(Iter first, Iter last, Pred pred);
 

test/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires ShuffleIterator<Iter> 
-//         && CopyConstructible<Pred> 
+// template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires ShuffleIterator<Iter>
+//         && CopyConstructible<Pred>
 //   Iter
 //   stable_partition(Iter first, Iter last, Pred pred);
 
@@ -300,7 +300,7 @@ test1()
     Iter r = std::stable_partition(Iter(array), Iter(array+size), is_null());
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {

test/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter> 
-//   requires ShuffleIterator<Iter> 
+// template<RandomAccessIterator Iter>
+//   requires ShuffleIterator<Iter>
 //   void
 //   random_shuffle(Iter first, Iter last);
 

test/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand> 
-//   requires ShuffleIterator<Iter> 
-//         && Convertible<Rand::result_type, Iter::difference_type> 
+// template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
+//   requires ShuffleIterator<Iter>
+//         && Convertible<Rand::result_type, Iter::difference_type>
 //   void
 //   random_shuffle(Iter first, Iter last, Rand&& rand);
 

test/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
-//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
-//         && HasEqualTo<Iter::value_type, T> 
+// template<ForwardIterator Iter, class T>
+//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
+//         && HasEqualTo<Iter::value_type, T>
 //   Iter
 //   remove(Iter first, Iter last, const T& value);
 
@@ -63,7 +63,7 @@ test1()
     assert(*ia[5] == 4);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -79,5 +79,5 @@ int main()
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter, class T> 
-//   requires HasEqualTo<InIter::value_type, T> 
+// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter, class T>
+//   requires HasEqualTo<InIter::value_type, T>
 //   OutIter
 //   remove_copy(InIter first, InIter last, OutIter result, const T& value);
 

test/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter, 
-//          Predicate<auto, InIter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter,
+//          Predicate<auto, InIter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   OutIter
 //   remove_copy_if(InIter first, InIter last, OutIter result, Pred pred);
 

test/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
-//         && CopyConstructible<Pred> 
+// template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
+//         && CopyConstructible<Pred>
 //   Iter
 //   remove_if(Iter first, Iter last, Pred pred);
 
@@ -72,7 +72,7 @@ test1()
     assert(*ia[5] == 4);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -88,5 +88,5 @@ int main()
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T> 
+// template<ForwardIterator Iter, class T>
 //   requires OutputIterator<Iter, Iter::reference>
 //         && OutputIterator<Iter, const T&>
-//         && HasEqualTo<Iter::value_type, T> 
+//         && HasEqualTo<Iter::value_type, T>
 //   void
 //   replace(Iter first, Iter last, const T& old_value, const T& new_value);
 

test/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, typename OutIter, class T> 
-//   requires OutputIterator<OutIter, InIter::reference> 
-//         && OutputIterator<OutIter, const T&> 
-//         && HasEqualTo<InIter::value_type, T> 
+// template<InputIterator InIter, typename OutIter, class T>
+//   requires OutputIterator<OutIter, InIter::reference>
+//         && OutputIterator<OutIter, const T&>
+//         && HasEqualTo<InIter::value_type, T>
 //   OutIter
 //   replace_copy(InIter first, InIter last, OutIter result, const T& old_value,
 //                                                           const T& new_value);

test/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, typename OutIter, 
-//          Predicate<auto, InIter::value_type> Pred, class T> 
-//   requires OutputIterator<OutIter, InIter::reference> 
-//         && OutputIterator<OutIter, const T&> 
-//         && CopyConstructible<Pred> 
+// template<InputIterator InIter, typename OutIter,
+//          Predicate<auto, InIter::value_type> Pred, class T>
+//   requires OutputIterator<OutIter, InIter::reference>
+//         && OutputIterator<OutIter, const T&>
+//         && CopyConstructible<Pred>
 //   OutIter
 //   replace_copy_if(InIter first, InIter last, OutIter result, Pred pred, const T& new_value);
 

test/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp

@@ -9,10 +9,10 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T> 
-//   requires OutputIterator<Iter, Iter::reference> 
-//         && OutputIterator<Iter, const T&> 
-//         && CopyConstructible<Pred> 
+// template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T>
+//   requires OutputIterator<Iter, Iter::reference>
+//         && OutputIterator<Iter, const T&>
+//         && CopyConstructible<Pred>
 //   void
 //   replace_if(Iter first, Iter last, Pred pred, const T& new_value);
 

test/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator Iter> 
-//   requires HasSwap<Iter::reference, Iter::reference> 
+// template<BidirectionalIterator Iter>
+//   requires HasSwap<Iter::reference, Iter::reference>
 //   void
 //   reverse(Iter first, Iter last);
 

test/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<BidirectionalIterator InIter, OutputIterator<auto, InIter::reference> OutIter> 
+// template<BidirectionalIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   OutIter
 //   reverse_copy(InIter first, InIter last, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<ShuffleIterator Iter> 
+// template<ShuffleIterator Iter>
 //   Iter
 //   rotate(Iter first, Iter middle, Iter last);
 
@@ -419,7 +419,7 @@ test1()
     assert(*ig[5] == 2);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -435,5 +435,5 @@ int main()
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp

@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<ForwardIterator InIter, OutputIterator<auto, InIter::reference> OutIter> 
+// template<ForwardIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
 //   OutIter
 //   rotate_copy(InIter first, InIter middle, InIter last, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<Iterator Iter1, Iterator Iter2> 
-//   requires HasSwap<Iter1::reference, Iter2::reference> 
+// template<Iterator Iter1, Iterator Iter2>
+//   requires HasSwap<Iter1::reference, Iter2::reference>
 //   void
 //   iter_swap(Iter1 a, Iter2 b);
 

test/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter1, ForwardIterator Iter2> 
-//   requires HasSwap<Iter1::reference, Iter2::reference> 
+// template<ForwardIterator Iter1, ForwardIterator Iter2>
+//   requires HasSwap<Iter1::reference, Iter2::reference>
 //   Iter2
 //   swap_ranges(Iter1 first1, Iter1 last1, Iter2 first2);
 
@@ -60,7 +60,7 @@ test1()
     assert(*j[2] == 3);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -106,5 +106,5 @@ int main()
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator InIter1, InputIterator InIter2, class OutIter, 
-//          Callable<auto, const InIter1::value_type&, const InIter2::value_type&> BinaryOp> 
-//   requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp> 
+// template<InputIterator InIter1, InputIterator InIter2, class OutIter,
+//          Callable<auto, const InIter1::value_type&, const InIter2::value_type&> BinaryOp>
+//   requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp>
 // OutIter
 // transform(InIter1 first1, InIter1 last1, InIter2 first2, OutIter result, BinaryOp binary_op);
 

test/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, class OutIter, 
-//          Callable<auto, const InIter::value_type&> Op> 
-//   requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op> 
+// template<InputIterator InIter, class OutIter,
+//          Callable<auto, const InIter::value_type&> Op>
+//   requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op>
 //   OutIter
 //   transform(InIter first, InIter last, OutIter result, Op op);
 

test/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter> 
+// template<ForwardIterator Iter>
 //   requires OutputIterator<Iter, Iter::reference>
-//         && EqualityComparable<Iter::value_type> 
+//         && EqualityComparable<Iter::value_type>
 //   Iter
 //   unique(Iter first, Iter last);
 
@@ -169,7 +169,7 @@ test1()
     assert(*ii[2] == 2);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -185,5 +185,5 @@ int main()
     test1<random_access_iterator<Ptr*> >();
     test1<Ptr*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

@@ -9,11 +9,11 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, class OutIter> 
-//   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type> 
-//         && EqualityComparable<InIter::value_type> 
-//         && HasAssign<InIter::value_type, InIter::reference> 
-//         && Constructible<InIter::value_type, InIter::reference> 
+// template<InputIterator InIter, class OutIter>
+//   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
+//         && EqualityComparable<InIter::value_type>
+//         && HasAssign<InIter::value_type, InIter::reference>
+//         && Constructible<InIter::value_type, InIter::reference>
 //   OutIter
 //   unique_copy(InIter first, InIter last, OutIter result);
 

test/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp

@@ -9,12 +9,12 @@
 
 // <algorithm>
 
-// template<InputIterator InIter, class OutIter, 
-//          EquivalenceRelation<auto, InIter::value_type> Pred> 
-//   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type> 
-//         && HasAssign<InIter::value_type, InIter::reference> 
-//         && Constructible<InIter::value_type, InIter::reference> 
-//         && CopyConstructible<Pred> 
+// template<InputIterator InIter, class OutIter,
+//          EquivalenceRelation<auto, InIter::value_type> Pred>
+//   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
+//         && HasAssign<InIter::value_type, InIter::reference>
+//         && Constructible<InIter::value_type, InIter::reference>
+//         && CopyConstructible<Pred>
 //   OutIter
 //   unique_copy(InIter first, InIter last, OutIter result, Pred pred);
 

test/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 
-//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
-//         && CopyConstructible<Pred> 
+// template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred>
+//   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
+//         && CopyConstructible<Pred>
 //   Iter
 //   unique(Iter first, Iter last, Pred pred);
 
@@ -211,7 +211,7 @@ test1()
     assert(count_equal::count == si-1);
 }
 
-#endif
+#endif  // _LIBCPP_MOVE
 
 int main()
 {
@@ -227,5 +227,5 @@ int main()
     test1<random_access_iterator<Ptr*> >();
     test1<Ptr*>();
 
-#endif
+#endif  // _LIBCPP_MOVE
 }

test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp

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

test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter
 //   adjacent_find(Iter first, Iter last, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.count/count.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter, class T> 
-//   requires HasEqualTo<Iter::value_type, T> 
+// template<InputIterator Iter, class T>
+//   requires HasEqualTo<Iter::value_type, T>
 //   Iter::difference_type
 //   count(Iter first, Iter last, const T& value);
 

test/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter::difference_type
 //   count_if(Iter first, Iter last, Pred pred);
 

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

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   bool
 //   equal(Iter1 first1, Iter1 last1, Iter2 first2);
 

test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2, 
-//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter1, InputIterator Iter2,
+//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   bool
 //   equal(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter1, ForwardIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<ForwardIterator Iter1, ForwardIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   Iter1
 //   find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 

test/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter1, ForwardIterator Iter2, 
-//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<ForwardIterator Iter1, ForwardIterator Iter2,
+//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter1
 //   find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, ForwardIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<InputIterator Iter1, ForwardIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   Iter1
 //   find_first_of(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 

test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, ForwardIterator Iter2, 
-//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter1, ForwardIterator Iter2,
+//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter1
 //   find_first_of(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

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

test/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter
 //   find_if(Iter first, Iter last, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   Iter
 //   find_if_not(Iter first, Iter last, Pred pred);
 

test/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter, Callable<auto, Iter::reference> Function> 
-//   requires CopyConstructible<Function> 
+// template<InputIterator Iter, Callable<auto, Iter::reference> Function>
+//   requires CopyConstructible<Function>
 //   Function
 //   for_each(Iter first, Iter last, Function f);
 

test/algorithms/alg.nonmodifying/alg.search/search.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter1, ForwardIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<ForwardIterator Iter1, ForwardIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   Iter1
 //   search(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 

test/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter1, ForwardIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<ForwardIterator Iter1, ForwardIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   Iter1
 //   search(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 

test/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp

@@ -9,8 +9,8 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2> 
-//   requires HasEqualTo<Iter1::value_type, Iter2::value_type> 
+// template<InputIterator Iter1, InputIterator Iter2>
+//   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
 //   pair<Iter1, Iter2>
 //   mismatch(Iter1 first1, Iter1 last1, Iter2 first2);
 

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

@@ -9,9 +9,9 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2, 
-//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> 
-//   requires CopyConstructible<Pred> 
+// template<InputIterator Iter1, InputIterator Iter2,
+//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
+//   requires CopyConstructible<Pred>
 //   pair<Iter1, Iter2>
 //   mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
 

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);