Fixing whitespace problems

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111753 91177308-0d34-0410-b5e6-96231b3b80d8
2010-08-22 00:08:10 +00:00
parent 16e6e1d72f
commit eb564e76cc
123 changed files with 369 additions and 380 deletions
--- a/test/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/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>

--- a/test/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ b/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()
 {
--- a/test/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
+++ b/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);
--- a/test/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ 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
 }
--- a/test/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ b/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
 }
--- a/test/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ b/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);

--- a/test/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ b/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
 }