int main() { test<bidirectional_iterator<int*> >(); test<random_access_iterator<int*> >(); test<int*>(); #if TEST_STD_VER >= 11 test<bidirectional_iterator<S*> >(); test<random_access_iterator<S*> >(); test<S*>(); { unsigned N = 100; unsigned M = 50; std::unique_ptr<int>* ia = new std::unique_ptr<int>[N]; for (unsigned i = 0; i < N; ++i) ia[i].reset(new int(i)); std::random_shuffle(ia, ia+N); std::sort(ia, ia+M, indirect_less()); std::sort(ia+M, ia+N, indirect_less()); std::inplace_merge(ia, ia+M, ia+N, indirect_less()); if(N > 0) { assert(*ia[0] == 0); assert(*ia[N-1] == N-1); assert(std::is_sorted(ia, ia+N, indirect_less())); } delete [] ia; } #endif // TEST_STD_VER >= 11 }
void test_9(int N) { std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::random_shuffle(ia, ia+N); CHECK(ranges::make_heap(ia, ia+N, indirect_less()) == ia+N); CHECK(std::is_heap(ia, ia+N, indirect_less())); delete [] ia; }
void test_move_only(int N) { auto const push_heap = make_testable_1(ranges::push_heap); std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::random_shuffle(ia, ia+N); for (int i = 0; i <= N; ++i) { push_heap(ia, ia+i, indirect_less()).check([&](std::unique_ptr<int> *r){CHECK(r == ia+i);}); CHECK(std::is_heap(ia, ia+i, indirect_less())); } delete [] ia; }
void test_9(int N) { std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::shuffle(ia, ia+N, gen); std::make_heap(ia, ia+N, indirect_less()); for (int i = N; i > 0; --i) { CHECK(ranges::pop_heap(ia, ia+i, indirect_less()) == ia+i); CHECK(std::is_heap(ia, ia+i-1, indirect_less())); } delete [] ia; }
int main() { int i = 0; std::partial_sort(&i, &i, &i); assert(i == 0); test_larger_sorts(10); test_larger_sorts(256); test_larger_sorts(257); test_larger_sorts(499); test_larger_sorts(500); test_larger_sorts(997); test_larger_sorts(1000); test_larger_sorts(1009); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { std::vector<std::unique_ptr<int> > v(1000); for (int i = 0; i < v.size(); ++i) v[i].reset(new int(i)); std::partial_sort(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less()); for (int i = 0; i < v.size()/2; ++i) assert(*v[i] == i); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main() { test(); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { std::vector<std::unique_ptr<int> > v(1000); for (int i = 0; i < v.size(); ++i) v[i].reset(new int(i)); std::stable_sort(v.begin(), v.end(), indirect_less()); assert(std::is_sorted(v.begin(), v.end(), indirect_less())); assert(*v[0] == 0); assert(*v[1] == 1); assert(*v[2] == 2); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main() { test(1000); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { const int N = 1000; std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::random_shuffle(ia, ia+N); for (int i = 0; i <= N; ++i) { std::push_heap(ia, ia+i, indirect_less()); assert(std::is_heap(ia, ia+i, indirect_less())); } delete [] ia; } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main(int, char**) { test(1000); #if TEST_STD_VER >= 11 { const int N = 1000; std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::shuffle(ia, ia+N, randomness); for (int i = 0; i <= N; ++i) { std::push_heap(ia, ia+i, indirect_less()); assert(std::is_heap(ia, ia+i, indirect_less())); } delete [] ia; } #endif return 0; }
int main() { test(0); test(1); test(2); test(3); test(10); test(1000); test(10000); test(100000); #if TEST_STD_VER >= 11 { const int N = 1000; std::unique_ptr<int>* ia = new std::unique_ptr<int> [N]; for (int i = 0; i < N; ++i) ia[i].reset(new int(i)); std::random_shuffle(ia, ia+N); std::make_heap(ia, ia+N, indirect_less()); assert(std::is_heap(ia, ia+N, indirect_less())); delete [] ia; } #endif }
int main() { int i = 0; int * res = ranges::partial_sort(&i, &i, &i); CHECK(i == 0); CHECK(res == &i); test_larger_sorts(10); test_larger_sorts(256); test_larger_sorts(257); test_larger_sorts(499); test_larger_sorts(500); test_larger_sorts(997); test_larger_sorts(1000); test_larger_sorts(1009); // Check move-only types { std::vector<std::unique_ptr<int> > v(1000); for(int i = 0; i < (int)v.size(); ++i) v[i].reset(new int((int)v.size() - i - 1)); ranges::partial_sort(v, v.begin() + v.size()/2, indirect_less()); for(int i = 0; i < (int)v.size()/2; ++i) CHECK(*v[i] == i); } // Check projections { std::vector<S> v(1000, S{}); for(int i = 0; (std::size_t)i < v.size(); ++i) { v[i].i = (int)v.size() - i - 1; v[i].j = i; } ranges::partial_sort(v, v.begin() + v.size()/2, std::less<int>{}, &S::i); for(int i = 0; (std::size_t)i < v.size()/2; ++i) { CHECK(v[i].i == i); CHECK((std::size_t)v[i].j == v.size() - i - 1); } } return ::test_result(); }
int main() { int d = 0; std::nth_element(&d, &d, &d); assert(d == 0); test(256); test(257); test(499); test(500); test(997); test(1000); test(1009); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { std::vector<std::unique_ptr<int> > v(1000); for (int i = 0; i < v.size(); ++i) v[i].reset(new int(i)); std::nth_element(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less()); assert(*v[v.size()/2] == v.size()/2); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main() { // test null range int d = 0; int * r = ranges::stable_sort(&d, &d); CHECK(r == &d); // exhaustively test all possibilities up to length 8 test_sort_<1>(); test_sort_<2>(); test_sort_<3>(); test_sort_<4>(); test_sort_<5>(); test_sort_<6>(); test_sort_<7>(); test_sort_<8>(); test_larger_sorts(15); test_larger_sorts(16); test_larger_sorts(17); test_larger_sorts(256); test_larger_sorts(257); test_larger_sorts(499); test_larger_sorts(500); test_larger_sorts(997); test_larger_sorts(1000); test_larger_sorts(1009); // Check move-only types { std::vector<std::unique_ptr<int> > v(1000); for(int i = 0; (std::size_t)i < v.size(); ++i) v[i].reset(new int(v.size() - i - 1)); ranges::stable_sort(v, indirect_less()); for(int i = 0; (std::size_t)i < v.size(); ++i) CHECK(*v[i] == i); } // Check projections { std::vector<S> v(1000, S{}); for(int i = 0; (std::size_t)i < v.size(); ++i) { v[i].i = v.size() - i - 1; v[i].j = i; } ranges::stable_sort(v, std::less<int>{}, &S::i); for(int i = 0; (std::size_t)i < v.size(); ++i) { CHECK(v[i].i == i); CHECK((std::size_t)v[i].j == v.size() - i - 1); } } // Check rvalue range { std::vector<S> v(1000, S{}); for(int i = 0; (std::size_t)i < v.size(); ++i) { v[i].i = v.size() - i - 1; v[i].j = i; } CHECK(ranges::stable_sort(ranges::view::all(v), std::less<int>{}, &S::i).get_unsafe() == v.end()); for(int i = 0; (std::size_t)i < v.size(); ++i) { CHECK(v[i].i == i); CHECK((std::size_t)v[i].j == v.size() - i - 1); } } return ::test_result(); }