void test_iter_4()
{
int i[3] = {1, 2, 3};
int j[4] = {4, 5, 6, 7};
std::pair<Iter1, Iter2> r = ranges::swap_ranges(Iter1(i), Iter1(i+3), Iter2(j), Iter2(j+4));
CHECK(base(r.first) == i+3);
CHECK(base(r.second) == j+3);
CHECK(i[0] == 4);
CHECK(i[1] == 5);
CHECK(i[2] == 6);
CHECK(j[0] == 1);
CHECK(j[1] == 2);
CHECK(j[2] == 3);
CHECK(j[3] == 7);
using Sent1 = typename sentinel_type<Iter1>::type;
using Sent2 = typename sentinel_type<Iter2>::type;
r = ranges::swap_ranges(Iter1(j), Sent1(j+4), Iter2(i), Sent2(i+3));
CHECK(base(r.first) == j+3);
CHECK(base(r.second) == i+3);
CHECK(i[0] == 1);
CHECK(i[1] == 2);
CHECK(i[2] == 3);
CHECK(j[0] == 4);
CHECK(j[1] == 5);
CHECK(j[2] == 6);
CHECK(j[3] == 7);
}
void test_comp() {
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {1, 2, 3, 3, 3, 4, 4};
const int sr = sizeof(ir)/sizeof(ir[0]);
auto set_difference = ::make_testable_2<false, true>([](auto&&... args) {
return ranges::set_difference(std::forward<decltype(args)>(args)...);
});
set_difference(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb), OutIter(ic), std::less<int>()).
check([&](ranges::set_difference_result<Iter1, OutIter> res)
{
CHECK(bool((base(res.in) - ia) == sa));
CHECK(bool((base(res.out) - ic) == sr));
CHECK(!std::lexicographical_compare(ic, base(res.out), ir, ir+sr));
ranges::fill(ic, 0);
}
);
int irr[] = {6};
const int srr = sizeof(irr)/sizeof(irr[0]);
set_difference(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa), OutIter(ic), std::less<int>()).
check([&](ranges::set_difference_result<Iter1, OutIter> res)
{
CHECK(bool((base(res.in) - ib) == sb));
CHECK(bool((base(res.out) - ic) == srr));
CHECK(!std::lexicographical_compare(ic, base(res.out), irr, irr+srr));
ranges::fill(ic, 0);
}
);
}
void
test_comp()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {1, 2, 3, 3, 3, 4, 4};
const int sr = sizeof(ir)/sizeof(ir[0]);
auto set_difference = ::make_testable_2<false, true>(ranges::set_difference);
set_difference(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb), OutIter(ic), std::less<int>()).
check([&](std::pair<Iter1, OutIter> res)
{
CHECK((base(res.first) - ia) == sa);
CHECK((base(res.second) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(res.second), ir, ir+sr) == 0);
ranges::fill(ic, 0);
}
);
int irr[] = {6};
const int srr = sizeof(irr)/sizeof(irr[0]);
set_difference(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa), OutIter(ic), std::less<int>()).
check([&](std::pair<Iter1, OutIter> res)
{
CHECK((base(res.first) - ib) == sb);
CHECK((base(res.second) - ic) == srr);
CHECK(std::lexicographical_compare(ic, base(res.second), irr, irr+srr) == 0);
ranges::fill(ic, 0);
}
);
}
void
test()
{
int i[3] = {1, 2, 3};
int j[3] = {4, 5, 6};
Iter2 r = std::swap_ranges(Iter1(i), Iter1(i+3), Iter2(j));
assert(base(r) == j+3);
assert(i[0] == 4);
assert(i[1] == 5);
assert(i[2] == 6);
assert(j[0] == 1);
assert(j[1] == 2);
assert(j[2] == 3);
}
void
test()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 6};
const int sr = sizeof(ir)/sizeof(ir[0]);
using R = std::tuple<Iter1, Iter2, OutIter>;
auto set_union = make_testable_2(ranges::set_union);
auto checker = [&](R res)
{
CHECK((base(std::get<2>(res)) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(std::get<2>(res)), ir, ir+sr) == false);
ranges::fill(ic, 0);
};
set_union(Iter1(ia), Iter1(ia+sa),
Iter2(ib), Iter2(ib+sb), OutIter(ic)).check(checker);
set_union(Iter1(ib), Iter1(ib+sb),
Iter2(ia), Iter2(ia+sa), OutIter(ic)).check(checker);
set_union(Iter1(ia), Iter1(ia+sa),
Iter2(ib), Iter2(ib+sb), OutIter(ic), std::less<int>()).check(checker);
set_union(Iter1(ib), Iter1(ib+sb),
Iter2(ia), Iter2(ia+sa), OutIter(ic), std::less<int>()).check(checker);
}
void test_rng_3()
{
int i[3] = {1, 2, 3};
int j[3] = {4, 5, 6};
std::pair<Iter1, Iter2> r = ranges::swap_ranges(as_lvalue(ranges::make_iterator_range(Iter1(i), Iter1(i+3))), Iter2(j));
CHECK(base(r.first) == i+3);
CHECK(base(r.second) == j+3);
CHECK(i[0] == 4);
CHECK(i[1] == 5);
CHECK(i[2] == 6);
CHECK(j[0] == 1);
CHECK(j[1] == 2);
CHECK(j[2] == 3);
using Sent1 = typename sentinel_type<Iter1>::type;
r = ranges::swap_ranges(as_lvalue(ranges::make_iterator_range(Iter1(j), Sent1(j+3))), Iter2(i));
CHECK(base(r.first) == j+3);
CHECK(base(r.second) == i+3);
CHECK(i[0] == 1);
CHECK(i[1] == 2);
CHECK(i[2] == 3);
CHECK(j[0] == 4);
CHECK(j[1] == 5);
CHECK(j[2] == 6);
}
void test_rng_4()
{
int i[3] = {1, 2, 3};
int j[4] = {4, 5, 6, 7};
std::pair<Iter1, Iter2> r = ranges::swap_ranges(
as_lvalue(ranges::make_iterator_range(Iter1(i), Iter1(i+3))),
as_lvalue(ranges::make_iterator_range(Iter2(j), Iter2(j+4))));
CHECK(base(r.first) == i+3);
CHECK(base(r.second) == j+3);
CHECK(i[0] == 4);
CHECK(i[1] == 5);
CHECK(i[2] == 6);
CHECK(j[0] == 1);
CHECK(j[1] == 2);
CHECK(j[2] == 3);
CHECK(j[3] == 7);
using Sent1 = typename sentinel_type<Iter1>::type;
using Sent2 = typename sentinel_type<Iter2>::type;
r = ranges::swap_ranges(
as_lvalue(ranges::make_iterator_range(Iter1(j), Sent1(j+4))),
as_lvalue(ranges::make_iterator_range(Iter2(i), Sent2(i+3))));
CHECK(base(r.first) == j+3);
CHECK(base(r.second) == i+3);
CHECK(i[0] == 1);
CHECK(i[1] == 2);
CHECK(i[2] == 3);
CHECK(j[0] == 4);
CHECK(j[1] == 5);
CHECK(j[2] == 6);
CHECK(j[3] == 7);
auto r2 = ranges::swap_ranges(
ranges::make_iterator_range(Iter1(j), Sent1(j+4)),
ranges::make_iterator_range(Iter2(i), Sent2(i+3)));
CHECK(base(r2.first.get_unsafe()) == j+3);
CHECK(base(r2.second.get_unsafe()) == i+3);
CHECK(i[0] == 4);
CHECK(i[1] == 5);
CHECK(i[2] == 6);
CHECK(j[0] == 1);
CHECK(j[1] == 2);
CHECK(j[2] == 3);
CHECK(j[3] == 7);
}
void
test1()
{
std::unique_ptr<int> i[3];
for (int k = 0; k < 3; ++k)
i[k].reset(new int(k+1));
std::unique_ptr<int> j[3];
for (int k = 0; k < 3; ++k)
j[k].reset(new int(k+4));
Iter2 r = std::swap_ranges(Iter1(i), Iter1(i+3), Iter2(j));
assert(base(r) == j+3);
assert(*i[0] == 4);
assert(*i[1] == 5);
assert(*i[2] == 6);
assert(*j[0] == 1);
assert(*j[1] == 2);
assert(*j[2] == 3);
}
void test_move_only()
{
std::unique_ptr<int> i[3];
for (int k = 0; k < 3; ++k)
i[k].reset(new int(k+1));
std::unique_ptr<int> j[3];
for (int k = 0; k < 3; ++k)
j[k].reset(new int(k+4));
std::pair<Iter1, Iter2> r = ranges::swap_ranges(Iter1(i), Iter1(i+3), Iter2(j));
CHECK(base(r.first) == i+3);
CHECK(base(r.second) == j+3);
CHECK(*i[0] == 4);
CHECK(*i[1] == 5);
CHECK(*i[2] == 6);
CHECK(*j[0] == 1);
CHECK(*j[1] == 2);
CHECK(*j[2] == 3);
}
void
test()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {1, 2, 3, 3, 3, 4, 4, 6};
const int sr = sizeof(ir)/sizeof(ir[0]);
OutIter ce = std::set_symmetric_difference(Iter1(ia), Iter1(ia+sa),
Iter2(ib), Iter2(ib+sb), OutIter(ic));
assert(base(ce) - ic == sr);
assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
ce = std::set_symmetric_difference(Iter1(ib), Iter1(ib+sb),
Iter2(ia), Iter2(ia+sa), OutIter(ic));
assert(base(ce) - ic == sr);
assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
}
TEST( ReverseIterator, CompatibilityReverse )
{
bolt::BCKND::device_vector< int > dV;
EXPECT_EQ( 0, dV.size( ) );
bolt::BCKND::device_vector< int >::reverse_iterator Iter0( dV, 0 );
bolt::BCKND::device_vector< int >::const_reverse_iterator cIter0( dV, 0 );
EXPECT_TRUE( Iter0 == cIter0 );
bolt::BCKND::device_vector< int >::reverse_iterator Iter1( dV, 0 );
bolt::BCKND::device_vector< int >::const_reverse_iterator cIter1( dV, 1 );
EXPECT_TRUE( Iter1 != cIter1 );
}
void
test()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {2, 4, 4};
const int sr = sizeof(ir)/sizeof(ir[0]);
auto set_intersection = ::make_testable_2<true, true>([](auto&&...args) {
return stl2::set_intersection(stl2::forward<decltype(args)>(args)...);
});
set_intersection(Iter1(ia), Iter1(ia+sa),
Iter2(ib), Iter2(ib+sb), OutIter(ic)).check([&](OutIter ce)
{
CHECK((base(ce) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
stl2::fill(ic, 0);
});
set_intersection(Iter1(ib), Iter1(ib+sb),
Iter2(ia), Iter2(ia+sa), OutIter(ic)).check([&](OutIter ce)
{
CHECK((base(ce) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
stl2::fill(ic, 0);
});
set_intersection(Iter1(ia), Iter1(ia+sa),
Iter2(ib), Iter2(ib+sb), OutIter(ic), std::less<int>()).check([&](OutIter ce)
{
CHECK((base(ce) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
stl2::fill(ic, 0);
});
set_intersection(Iter1(ib), Iter1(ib+sb),
Iter2(ia), Iter2(ia+sa), OutIter(ic), std::less<int>()).check([&](OutIter ce)
{
CHECK((base(ce) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
stl2::fill(ic, 0);
});
}
void
test_iter()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const int sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4, 4, 6};
const int sb = sizeof(ib)/sizeof(ib[0]);
int ic[20];
int ir[] = {1, 2, 3, 3, 3, 4, 4};
const int sr = sizeof(ir)/sizeof(ir[0]);
auto set_difference = ::make_testable_2<false, true>([](auto&&...args) {
return stl2::set_difference(stl2::forward<decltype(args)>(args)...);
});
set_difference(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb), OutIter(ic)).
check([&](std::pair<Iter1, OutIter> res)
{
CHECK((base(res.first) - ia) == sa);
CHECK((base(res.second) - ic) == sr);
CHECK(std::lexicographical_compare(ic, base(res.second), ir, ir+sr) == 0);
stl2::fill(ic, 0);
}
);
int irr[] = {6};
const int srr = sizeof(irr)/sizeof(irr[0]);
set_difference(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa), OutIter(ic)).
check([&](std::pair<Iter1, OutIter> res)
{
CHECK((base(res.first) - ib) == sb);
CHECK((base(res.second) - ic) == srr);
CHECK(std::lexicographical_compare(ic, base(res.second), irr, irr+srr) == 0);
stl2::fill(ic, 0);
}
);
}
void
test_iter1()
{
int ia[] = {1, 2, 3, 4};
constexpr unsigned sa = ranges::size(ia);
int ib[] = {1, 2, 3};
CHECK(!ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib), Sent2(ib+2)));
CHECK(ranges::lexicographical_compare(Iter1(ib), Sent1(ib+2), Iter2(ia), Sent2(ia+sa)));
CHECK(!ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib), Sent2(ib+3)));
CHECK(ranges::lexicographical_compare(Iter1(ib), Sent1(ib+3), Iter2(ia), Sent2(ia+sa)));
CHECK(ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib+1), Sent2(ib+3)));
CHECK(!ranges::lexicographical_compare(Iter1(ib+1), Sent1(ib+3), Iter2(ia), Sent2(ia+sa)));
}
TEST( ReverseIterator, OperatorEqualReverse )
{
bolt::BCKND::device_vector< int > dV;
EXPECT_EQ( 0, dV.size( ) );
bolt::BCKND::device_vector< int >::reverse_iterator Iter0( dV, 0 );
bolt::BCKND::device_vector< int >::reverse_iterator cIter0( dV, 0 );
EXPECT_TRUE( Iter0 == cIter0 );
bolt::BCKND::device_vector< int >::const_reverse_iterator Iter1( dV, 0 );
bolt::BCKND::device_vector< int >::const_reverse_iterator cIter1( dV, 1 );
EXPECT_TRUE( Iter1 != cIter1 );
bolt::BCKND::device_vector< int > dV2;
bolt::BCKND::device_vector< int >::const_reverse_iterator Iter2( dV, 0 );
bolt::BCKND::device_vector< int >::const_reverse_iterator cIter2( dV2, 0 );
EXPECT_TRUE( Iter2 != cIter2 );
}
void
test_iter_comp1()
{
int ia[] = {1, 2, 3, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 2, 3};
typedef std::greater<int> C;
C c;
CHECK(!ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib), Sent2(ib+2), c));
CHECK(ranges::lexicographical_compare(Iter1(ib), Sent1(ib+2), Iter2(ia), Sent2(ia+sa), c));
CHECK(!ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib), Sent2(ib+3), c));
CHECK(ranges::lexicographical_compare(Iter1(ib), Sent1(ib+3), Iter2(ia), Sent2(ia+sa), c));
CHECK(!ranges::lexicographical_compare(Iter1(ia), Sent1(ia+sa), Iter2(ib+1), Sent2(ib+3), c));
CHECK(ranges::lexicographical_compare(Iter1(ib+1), Sent1(ib+3), Iter2(ia), Sent2(ia+sa), c));
}
void
test2()
{
char ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), Iter1(ia), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), Iter1(ia+1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), Iter1(ia+2), sa);
do_search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), Iter1(ia), 0);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
do_search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), Iter1(ia), sa*sa);
do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
do_search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), Iter1(ia+1), sa);
char ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
char ic[] = {1};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
char id[] = {1, 2};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
char ie[] = {1, 2, 3};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
char ig[] = {1, 2, 3, 4};
do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
char ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
char ii[] = {1, 1, 2};
do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3), sh*3);
}
int main()
{
test<input_iterator<const int*>, input_iterator<const int*> >();
test<input_iterator<const int*>, forward_iterator<const int*> >();
test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
test<input_iterator<const int*>, random_access_iterator<const int*> >();
test<input_iterator<const int*>, const int*>();
test<forward_iterator<const int*>, input_iterator<const int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*> >();
test<forward_iterator<const int*>, const int*>();
test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
test<bidirectional_iterator<const int*>, const int*>();
test<random_access_iterator<const int*>, input_iterator<const int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
test<random_access_iterator<const int*>, const int*>();
test<const int*, input_iterator<const int*> >();
test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>();
// Test initializer lists:
CHECK(ranges::inner_product({1,2,3}, {4,5,6}, 0) == 32);
// test projections:
{
S a[] = {{1}, {2}, {3}, {4}, {5}, {6}};
S b[] = {{6}, {5}, {4}, {3}, {2}, {1}};
unsigned sa = sizeof(a) / sizeof(a[0]);
using Iter1 = input_iterator<const S*>;
using Sent1 = input_iterator<const S*>;
using Iter2 = Iter1;
// rng + bops:
auto bops = [&](S* b1, int l1, S* b2, int i)
{
return ranges::inner_product(ranges::make_iterator_range(Iter1(b1), Sent1(b1+l1)),
ranges::make_iterator_range(Iter2(b2), Iter2(b2+l1)), i,
std::multiplies<int>(), std::plus<int>(),
&S::i, &S::i);
};
CHECK(bops(a, 0, b, 1) == 1);
CHECK(bops(a, 0, b, 10) == 10);
CHECK(bops(a, 1, b, 1) == 7);
CHECK(bops(a, 1, b, 10) == 70);
CHECK(bops(a, 2, b, 1) == 49);
CHECK(bops(a, 2, b, 10) == 490);
CHECK(bops(a, sa, b, 1) == 117649);
CHECK(bops(a, sa, b, 10) == 1176490);
}
{
int a[] = {1, 2, 3, 4, 5, 6};
int b[] = {6, 5, 4, 3, 2, 1};
// raw array test:
CHECK(ranges::inner_product(a, b, 0) == 56);
CHECK(ranges::inner_product(a, b, 10) == 66);
}
return ::test_result();
}
void
test()
{
int ia[] = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {2, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1, 2};
const unsigned sc = sizeof(ic)/sizeof(ic[0]);
int id[] = {3, 3, 3, 3};
const unsigned sd = sizeof(id)/sizeof(id[0]);
assert(std::includes(Iter1(ia), Iter1(ia), Iter2(ib), Iter2(ib), std::less<int>()));
assert(!std::includes(Iter1(ia), Iter1(ia), Iter2(ib), Iter2(ib+1), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+1), Iter2(ib), Iter2(ib), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+sb), std::less<int>()));
assert(!std::includes(Iter1(ib), Iter1(ib+sb), Iter2(ia), Iter2(ia+sa), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+2), Iter2(ic), Iter2(ic+2), std::less<int>()));
assert(!std::includes(Iter1(ia), Iter1(ia+2), Iter2(ib), Iter2(ib+2), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+1), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2), std::less<int>()));
assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3), std::less<int>()));
assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::less<int>()));
}
void
test()
{
int ia[] = {1, 2, 3, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 2, 3};
assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+2)));
assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+2), Iter2(ia), Iter2(ia+sa)));
assert(!std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib), Iter2(ib+3)));
assert( std::lexicographical_compare(Iter1(ib), Iter1(ib+3), Iter2(ia), Iter2(ia+sa)));
assert( std::lexicographical_compare(Iter1(ia), Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3)));
assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3), Iter2(ia), Iter2(ia+sa)));
}
void
test()
{
int a[] = {1, 2, 3, 4, 5, 6};
int b[] = {6, 5, 4, 3, 2, 1};
unsigned sa = sizeof(a) / sizeof(a[0]);
test(Iter1(a), Iter1(a), Iter2(b), 1, 1);
test(Iter1(a), Iter1(a), Iter2(b), 10, 10);
test(Iter1(a), Iter1(a+1), Iter2(b), 1, 7);
test(Iter1(a), Iter1(a+1), Iter2(b), 10, 70);
test(Iter1(a), Iter1(a+2), Iter2(b), 1, 49);
test(Iter1(a), Iter1(a+2), Iter2(b), 10, 490);
test(Iter1(a), Iter1(a+sa), Iter2(b), 1, 117649);
test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490);
}
void
test()
{
int ia[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int b[] = {0};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b+1), count_equal()) == Iter1(ia+sa-1));
assert(count_equal::count <= 1*(sa-1+1));
int c[] = {0, 1};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(c), Iter2(c+2), count_equal()) == Iter1(ia+18));
assert(count_equal::count <= 2*(sa-2+1));
int d[] = {0, 1, 2};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(d), Iter2(d+3), count_equal()) == Iter1(ia+15));
assert(count_equal::count <= 3*(sa-3+1));
int e[] = {0, 1, 2, 3};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(e), Iter2(e+4), count_equal()) == Iter1(ia+11));
assert(count_equal::count <= 4*(sa-4+1));
int f[] = {0, 1, 2, 3, 4};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(f), Iter2(f+5), count_equal()) == Iter1(ia+6));
assert(count_equal::count <= 5*(sa-5+1));
int g[] = {0, 1, 2, 3, 4, 5};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(g), Iter2(g+6), count_equal()) == Iter1(ia));
assert(count_equal::count <= 6*(sa-6+1));
int h[] = {0, 1, 2, 3, 4, 5, 6};
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(h), Iter2(h+7), count_equal()) == Iter1(ia+sa));
assert(count_equal::count <= 7*(sa-7+1));
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b), count_equal()) == Iter1(ia+sa));
assert(count_equal::count <= 0);
count_equal::count = 0;
assert(std::find_end(Iter1(ia), Iter1(ia), Iter2(b), Iter2(b+1), count_equal()) == Iter1(ia));
assert(count_equal::count <= 0);
}
void
test()
{
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2)) == Iter1(ia+1));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2));
assert(std::search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa)) == Iter1(ia+sa-1));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa)) == Iter1(ia+sa-3));
assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa)) == Iter1(ia));
assert(std::search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+sa-1));
assert(std::search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+1));
int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int ic[] = {1};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1)) == Iter1(ib+1));
int id[] = {1, 2};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2)) == Iter1(ib+1));
int ie[] = {1, 2, 3};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3)) == Iter1(ib+4));
int ig[] = {1, 2, 3, 4};
assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4)) == Iter1(ib+8));
int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int ii[] = {1, 1, 2};
assert(std::search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3)) == Iter1(ih+3));
int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sj = sizeof(ij)/sizeof(ij[0]);
int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
const unsigned sk = sizeof(ik)/sizeof(ik[0]);
assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6));
}
