generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fixing whitespace problems

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111753 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant 2010-08-22 00:08:10 +00:00
parent 16e6e1d72f
commit eb564e76cc
123 changed files with 369 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
View File

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

2
test/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
View File

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

1
test/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
View File

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

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

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

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

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

10
test/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
View File

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

10
test/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
View File

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

10
test/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
View File

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

2
test/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
View File

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

2
test/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
View File

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

4
test/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
View File

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

6
test/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
View File

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

8
test/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
View File

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

10
test/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
View File

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

12
test/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
View File

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

10
test/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
View File

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

6
test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
View File

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

6
test/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
View File

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

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

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

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

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

4
test/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
View File

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

4
test/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
View File

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

6
test/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

6
test/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
View File

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

10
test/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
View File

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

8
test/algorithms/alg.sorting/alg.merge/merge.pass.cpp
View File

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

8
test/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
View File

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

8
test/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
View File

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

10
test/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
View File

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

4
test/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
View File

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

6
test/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
View File

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

Some files were not shown because too many files have changed in this diff Show More