void test() {
const unsigned n = 4;
int ia[n] = {0};
auto f = gen_test{1};
auto res1 = ranges::generate(Iter(ia), Sent(ia + n), ranges::ref(f));
CHECK(ia[0] == 1);
CHECK(ia[1] == 2);
CHECK(ia[2] == 3);
CHECK(ia[3] == 4);
CHECK(res1 == Iter(ia + n));
CHECK(f.i_ == 5);
auto rng = ranges::subrange(Iter(ia), Sent(ia + n));
auto res2 = ranges::generate(rng, ranges::ref(f));
CHECK(ia[0] == 5);
CHECK(ia[1] == 6);
CHECK(ia[2] == 7);
CHECK(ia[3] == 8);
CHECK(res2 == Iter(ia + n));
CHECK(f.i_ == 9);
auto res3 = ranges::generate(std::move(rng), ranges::ref(f));
CHECK(ia[0] == 9);
CHECK(ia[1] == 10);
CHECK(ia[2] == 11);
CHECK(ia[3] == 12);
CHECK(res3 == Iter(ia + n));
CHECK(f.i_ == 13);
}
void
test_range()
{
{
const int ia[] = {1, 2, 3, 4, 5, 6};
CHECK(!ranges::is_partitioned(ranges::make_subrange(Iter(ranges::begin(ia)),
Sent(ranges::end(ia))),
is_odd()));
}
{
const int ia[] = {1, 3, 5, 2, 4, 6};
CHECK( ranges::is_partitioned(ranges::make_subrange(Iter(ranges::begin(ia)),
Sent(ranges::end(ia))),
is_odd()));
}
{
const int ia[] = {2, 4, 6, 1, 3, 5};
CHECK(!ranges::is_partitioned(ranges::make_subrange(Iter(ranges::begin(ia)),
Sent(ranges::end(ia))),
is_odd()));
}
{
const int ia[] = {1, 3, 5, 2, 4, 6, 7};
CHECK(!ranges::is_partitioned(ranges::make_subrange(Iter(ranges::begin(ia)),
Sent(ranges::end(ia))),
is_odd()));
}
{
const int ia[] = {1, 3, 5, 2, 4, 6, 7};
CHECK( ranges::is_partitioned(ranges::make_subrange(Iter(ranges::begin(ia)),
Sent(ranges::begin(ia))),
is_odd()));
}
}
void
test_char()
{
const unsigned n = 4;
char ca[n] = {0};
auto i = ranges::fill(Iter(ca), Sent(ca+n), char(1));
CHECK(ca[0] == 1);
CHECK(ca[1] == 1);
CHECK(ca[2] == 1);
CHECK(ca[3] == 1);
CHECK(i == Iter(ca + 4));
auto rng = ranges::make_iterator_range(Iter(ca), Sent(ca+n));
i = ranges::fill(rng, char(2));
CHECK(ca[0] == 2);
CHECK(ca[1] == 2);
CHECK(ca[2] == 2);
CHECK(ca[3] == 2);
CHECK(i == Iter(ca + 4));
auto j = ranges::fill(ranges::make_iterator_range(Iter(ca), Sent(ca+n)), char(3));
CHECK(ca[0] == 3);
CHECK(ca[1] == 3);
CHECK(ca[2] == 3);
CHECK(ca[3] == 3);
CHECK(j.get_unsafe() == Iter(ca + 4));
}
void test_range()
{
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
constexpr unsigned sa = ranges::size(ia);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
using Pair = std::pair<Iter, Iter>;
auto rng1 = ranges::make_range(Iter(ia), Sent(ia + sa));
CHECK(ranges::mismatch(rng1, Iter(ib)) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng2 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng3 = ranges::make_range(Iter(ib),Sent(ib + sa));
CHECK(ranges::mismatch(rng2,rng3) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng4 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng5 = ranges::make_range(Iter(ib),Sent(ib + 2));
CHECK(ranges::mismatch(rng4,rng5) ==
Pair{Iter(ia+2),Iter(ib+2)});
auto rng6 = ranges::make_range(Iter(ia),Sent(ia + sa));
CHECK(ranges::mismatch(rng6,Iter(ib),std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng7 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng8 = ranges::make_range(Iter(ib),Sent(ib + sa));
CHECK(ranges::mismatch(rng7,rng8,std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng9 = ranges::make_range(Iter(ia), Sent(ia + sa));
auto rng10 = ranges::make_range(Iter(ib), Sent(ib + 2));
CHECK(ranges::mismatch(rng9,rng10,std::equal_to<int>()) ==
Pair{Iter(ia+2),Iter(ib+2)});
}
void
test_char()
{
const unsigned n = 4;
char ca[n] = {0};
auto i = ranges::fill(Iter(ca), Sent(ca+n), char(1));
CHECK(ca[0] == 1);
CHECK(ca[1] == 1);
CHECK(ca[2] == 1);
CHECK(ca[3] == 1);
CHECK(i == Iter(ca + 4));
auto rng = ranges::make_subrange(Iter(ca), Sent(ca+n));
i = ranges::fill(rng, char(2));
CHECK(ca[0] == 2);
CHECK(ca[1] == 2);
CHECK(ca[2] == 2);
CHECK(ca[3] == 2);
CHECK(i == Iter(ca + 4));
auto j = ranges::fill(::MakeTestRange(Iter(ca), Sent(ca+n)), char(3));
CHECK(ca[0] == 3);
CHECK(ca[1] == 3);
CHECK(ca[2] == 3);
CHECK(ca[3] == 3);
CHECK(::is_dangling(j));
}
void
test_char()
{
const unsigned n = 4;
char ca[n] = {0};
auto i = count_and_fill(Iter(ca), Sent(ca+n), char(1));
CHECK(ca[0] == 1);
CHECK(ca[1] == 1);
CHECK(ca[2] == 1);
CHECK(ca[3] == 1);
CHECK(i == Iter(ca + 4));
auto rng = stl2::ext::make_range(Iter(ca), Sent(ca+n));
i = count_and_fill(rng, char(2));
CHECK(ca[0] == 2);
CHECK(ca[1] == 2);
CHECK(ca[2] == 2);
CHECK(ca[3] == 2);
CHECK(i == Iter(ca + 4));
auto j = count_and_fill(stl2::ext::make_range(Iter(ca), Sent(ca+n)), char(3));
CHECK(ca[0] == 3);
CHECK(ca[1] == 3);
CHECK(ca[2] == 3);
CHECK(ca[3] == 3);
CHECK(j.get_unsafe() == Iter(ca + 4));
}
void
test_one_rng(unsigned N, unsigned M)
{
assert(M <= N);
int* ia = new int[N];
for (unsigned i = 0; i < N; ++i)
ia[i] = i;
std::random_shuffle(ia, ia+N);
std::sort(ia, ia+M);
std::sort(ia+M, ia+N);
auto res = ranges::inplace_merge(::as_lvalue(ranges::make_range(Iter(ia), Sent(ia+N))), Iter(ia+M));
CHECK(res == Iter(ia+N));
if(N > 0)
{
CHECK(ia[0] == 0);
CHECK(ia[N-1] == (int)N-1);
CHECK(std::is_sorted(ia, ia+N));
}
std::random_shuffle(ia, ia+N);
std::sort(ia, ia+M);
std::sort(ia+M, ia+N);
auto res2 = ranges::inplace_merge(ranges::make_range(Iter(ia), Sent(ia+N)), Iter(ia+M));
CHECK(res2.get_unsafe() == Iter(ia+N));
if(N > 0)
{
CHECK(ia[0] == 0);
CHECK(ia[N-1] == (int)N-1);
CHECK(std::is_sorted(ia, ia+N));
}
delete [] ia;
}
void
test1()
{
{
const int N = 100;
std::unique_ptr<int> ia[N];
for(int i = 0; i < N; ++i)
ia[i].reset(new int(i));
std::unique_ptr<int> ib[N];
std::pair<InIter, OutIter> r = ranges::move(InIter(ia), Sent(ia+N), OutIter(ib));
CHECK(base(r.first) == ia+N);
CHECK(base(r.second) == ib+N);
for(int i = 0; i < N; ++i)
{
CHECK(ia[i].get() == nullptr);
CHECK(*ib[i] == i);
}
}
{
const int N = 100;
std::unique_ptr<int> ia[N];
for(int i = 0; i < N; ++i)
ia[i].reset(new int(i));
std::unique_ptr<int> ib[N];
std::pair<InIter, OutIter> r = ranges::move(as_lvalue(ranges::make_iterator_range(InIter(ia), Sent(ia+N))), OutIter(ib));
CHECK(base(r.first) == ia+N);
CHECK(base(r.second) == ib+N);
for(int i = 0; i < N; ++i)
{
CHECK(ia[i].get() == nullptr);
CHECK(*ib[i] == i);
}
ranges::move(ib, ib+N, ia);
auto r2 = ranges::move(ranges::make_iterator_range(InIter(ia), Sent(ia+N)), OutIter(ib));
CHECK(base(r2.first.get_unsafe()) == ia+N);
CHECK(base(r2.second) == ib+N);
for(int i = 0; i < N; ++i)
{
CHECK(ia[i].get() == nullptr);
CHECK(*ib[i] == i);
}
}
}
void test_iter_comp()
{
typedef std::greater<int> C;
int ia[] = {6, 5, 4, 3, 2, 1};
const int sa = sizeof(ia)/sizeof(ia[0]);
int prev[sa];
for(int e = 0; e <= sa; ++e)
{
int count = 0;
bool x;
do
{
std::copy(ia, ia+e, prev);
x = ranges::next_permutation(Iter(ia), Sent(ia+e), C());
if(e > 1)
{
if (x)
CHECK(std::lexicographical_compare(prev, prev+e, ia, ia+e, C()));
else
CHECK(std::lexicographical_compare(ia, ia+e, prev, prev+e, C()));
}
++count;
} while (x);
CHECK(count == factorial(e));
}
}
void
test()
{
{
const int N = 1000;
int ia[N];
for(int i = 0; i < N; ++i)
ia[i] = i;
int ib[N] = {0};
std::pair<InIter, OutIter> r = ranges::move(InIter(ia), Sent(ia+N), OutIter(ib));
CHECK(base(r.first) == ia+N);
CHECK(base(r.second) == ib+N);
for(int i = 0; i < N; ++i)
CHECK(ia[i] == ib[i]);
}
{
const int N = 1000;
int ia[N];
for(int i = 0; i < N; ++i)
ia[i] = i;
int ib[N] = {0};
std::pair<InIter, OutIter> r = ranges::move(as_lvalue(ranges::make_iterator_range(InIter(ia), Sent(ia+N))), OutIter(ib));
CHECK(base(r.first) == ia+N);
CHECK(base(r.second) == ib+N);
for(int i = 0; i < N; ++i)
CHECK(ia[i] == ib[i]);
}
}
void RequestQueue::Sent(time_t timestamp, bt_index_t idx, bt_offset_t off,
bt_length_t len)
{
SLICE *slice;
if( (slice = FindSlice(idx, off, len)) )
Sent(timestamp, slice);
}
void test_range()
{
int ia[] = {1, 2, 3, 4, 5, 6};
const int sa = sizeof(ia)/sizeof(ia[0]);
int prev[sa];
for (int e = 0; e <= sa; ++e)
{
int count = 0;
bool x;
do
{
std::copy(ia, ia+e, prev);
x = ranges::next_permutation(ranges::ext::make_range(Iter(ia), Sent(ia+e)));
if(e > 1)
{
if(x)
CHECK(std::lexicographical_compare(prev, prev+e, ia, ia+e));
else
CHECK(std::lexicographical_compare(ia, ia+e, prev, prev+e));
}
++count;
} while(x);
CHECK(count == factorial(e));
}
}
void test()
{
int ir[] = {5, 6, 7, 8, 9};
constexpr auto s = ranges::size(ir);
{
int ia[] = {1, 2, 3, 4, 5};
ranges::iota(Iter(ia), Sent(ia + s), 5);
CHECK(ranges::equal(ia, ir));
}
{
int ia[] = {1, 2, 3, 4, 5};
auto rng = ranges::make_subrange(Iter(ia), Sent(ia + s));
ranges::iota(rng, 5);
CHECK(ranges::equal(ia, ir));
}
}
void
test_iter(unsigned N)
{
std::unique_ptr<int[]> a{new int[N]};
std::iota(a.get(), a.get()+N, 0);
std::shuffle(a.get(), a.get()+N, gen);
test_iter(Iter(a.get()), Sent(a.get()+N));
}
void
test_int()
{
const unsigned n = 4;
int ia[n] = {0};
count_and_fill(Iter(ia), Sent(ia+n), 1);
CHECK(ia[0] == 1);
CHECK(ia[1] == 1);
CHECK(ia[2] == 1);
CHECK(ia[3] == 1);
auto rng = stl2::ext::make_range(Iter(ia), Sent(ia+n));
count_and_fill(rng, 2);
CHECK(ia[0] == 2);
CHECK(ia[2] == 2);
CHECK(ia[2] == 2);
CHECK(ia[3] == 2);
}
void
test_int()
{
const unsigned n = 4;
int ia[n] = {0};
ranges::fill(Iter(ia), Sent(ia+n), 1);
CHECK(ia[0] == 1);
CHECK(ia[1] == 1);
CHECK(ia[2] == 1);
CHECK(ia[3] == 1);
auto rng = ranges::make_subrange(Iter(ia), Sent(ia+n));
ranges::fill(rng, 2);
CHECK(ia[0] == 2);
CHECK(ia[2] == 2);
CHECK(ia[2] == 2);
CHECK(ia[3] == 2);
}
void test_range()
{
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
constexpr unsigned sa = ranges::size(ia);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
using Pair = std::pair<Iter, Iter>;
auto rng1 = ranges::make_range(Iter(ia), Sent(ia + sa));
CHECK(ranges::mismatch(rng1, Iter(ib)) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto r1 = ranges::mismatch(std::move(rng1), Iter(ib));
CHECK(r1.first.get_unsafe() == Iter(ia+3));
CHECK(r1.second == Iter(ib+3));
auto rng2 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng3 = ranges::make_range(Iter(ib),Sent(ib + sa));
CHECK(ranges::mismatch(rng2,rng3) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto r2 = ranges::mismatch(std::move(rng2), std::move(rng3));
CHECK(r2.first.get_unsafe() == Iter(ia+3));
CHECK(r2.second.get_unsafe() == Iter(ib+3));
auto r3 = ranges::mismatch(rng2, std::move(rng3));
CHECK(r3.first == Iter(ia+3));
CHECK(r3.second.get_unsafe() == Iter(ib+3));
auto r4 = ranges::mismatch(std::move(rng2), rng3);
CHECK(r4.first.get_unsafe() == Iter(ia+3));
CHECK(r4.second == Iter(ib+3));
auto rng4 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng5 = ranges::make_range(Iter(ib),Sent(ib + 2));
CHECK(ranges::mismatch(rng4,rng5) ==
Pair{Iter(ia+2),Iter(ib+2)});
auto rng6 = ranges::make_range(Iter(ia),Sent(ia + sa));
CHECK(ranges::mismatch(rng6,Iter(ib),std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng7 = ranges::make_range(Iter(ia),Sent(ia + sa));
auto rng8 = ranges::make_range(Iter(ib),Sent(ib + sa));
CHECK(ranges::mismatch(rng7,rng8,std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
auto rng9 = ranges::make_range(Iter(ia), Sent(ia + sa));
auto rng10 = ranges::make_range(Iter(ib), Sent(ib + 2));
CHECK(ranges::mismatch(rng9,rng10,std::equal_to<int>()) ==
Pair{Iter(ia+2),Iter(ib+2)});
}
void test_iter()
{
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
constexpr unsigned sa = ranges::size(ia);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
using Pair = std::pair<Iter, Iter>;
CHECK(ranges::mismatch(Iter(ia), Sent(ia + sa), Iter(ib)) ==
Pair{Iter(ia+3),Iter(ib+3)});
CHECK(ranges::mismatch(Iter(ia),Sent(ia + sa),Iter(ib),Sent(ib + sa)) ==
Pair{Iter(ia+3),Iter(ib+3)});
CHECK(ranges::mismatch(Iter(ia),Sent(ia + sa),Iter(ib),Sent(ib + 2)) ==
Pair{Iter(ia+2),Iter(ib+2)});
CHECK(ranges::mismatch(Iter(ia),Sent(ia + sa),Iter(ib),std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
CHECK(ranges::mismatch(Iter(ia),Sent(ia + sa),Iter(ib),Sent(ib + sa),std::equal_to<int>()) ==
Pair{Iter(ia+3),Iter(ib+3)});
CHECK(ranges::mismatch(Iter(ia), Sent(ia + sa), Iter(ib), Sent(ib + 2), std::equal_to<int>()) ==
Pair{Iter(ia+2),Iter(ib+2)});
}
void test_iter()
{
int ia[] = {0, 1, 2, 3, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
Iter i = ranges::replace_if(Iter(ia), Sent(ia+sa), [](int i){return i==2;}, 5);
CHECK(ia[0] == 0);
CHECK(ia[1] == 1);
CHECK(ia[2] == 5);
CHECK(ia[3] == 3);
CHECK(ia[4] == 4);
CHECK(base(i) == ia + sa);
}
void
test()
{
const unsigned n = 4;
int ia[n] = {0};
std::pair<Iter, gen_test> res = ranges::generate(Iter(ia), Sent(ia + n), gen_test(1));
CHECK(ia[0] == 1);
CHECK(ia[1] == 2);
CHECK(ia[2] == 3);
CHECK(ia[3] == 4);
CHECK(res.first == Iter(ia + n));
CHECK(res.second.i_ == 5);
auto rng = ranges::range(Iter(ia), Sent(ia + n));
res = ranges::generate(rng, res.second);
CHECK(ia[0] == 5);
CHECK(ia[1] == 6);
CHECK(ia[2] == 7);
CHECK(ia[3] == 8);
CHECK(res.first == Iter(ia + n));
CHECK(res.second.i_ == 9);
}
void test_iter()
{
int ia[] = {0, 1, 2, 3, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[sa] = {0};
std::pair<InIter, OutIter> r = ranges::replace_copy(InIter(ia), Sent(ia+sa), OutIter(ib), 2, 5);
CHECK(base(r.first) == ia + sa);
CHECK(base(r.second) == ib + sa);
CHECK(ib[0] == 0);
CHECK(ib[1] == 1);
CHECK(ib[2] == 5);
CHECK(ib[3] == 3);
CHECK(ib[4] == 4);
}
/**
* @param int 二进制位表示要显示的数码管位置。1表示选中，0未选中。高位表示左边晶体管，低位在右
* @param int 表示要显示的值，支持16进制字符。16表示消影
* @param int 表示是否有小数点
*/
void Display(int loca, int num, int boo)
{
int lo, i, temp;
loca = ~loca; //使得1表示选中，0表示未选中
lo = 0;
for (i = 0; i < 8; i++) //lo为loca左右颠倒
{ //使得高位表示左边晶体管，低位在右
lo <<= 1;
if (loca & 0x01)
lo |= 0x01;
loca >>= 1;
}
temp = encode[num]; //对编码添加小数点
if (boo)
{
temp |= 0x80;
}
Sent(lo); //发送要显示的位置，8位
Sent(temp); //发送要显示的值，将前8位位置数据推送至下一个串联的移位寄存器
RCK = 0; //产生一个上沿，输出存储器中锁存的数据
RCK = 1;
}
void
test_iter()
{
int ia[] = {0, 1, 2, 3, 4, 2, 3, 4, 2};
constexpr unsigned sa = stl2::size(ia);
Iter r = stl2::remove(Iter(ia), Sent(ia+sa), 2);
CHECK(base(r) == ia + sa-3);
CHECK(ia[0] == 0);
CHECK(ia[1] == 1);
CHECK(ia[2] == 3);
CHECK(ia[3] == 4);
CHECK(ia[4] == 3);
CHECK(ia[5] == 4);
}
void
test_range()
{
int ia[] = {0, 1, 2, 3, 4, 2, 3, 4, 2};
constexpr unsigned sa = stl2::size(ia);
Iter r = stl2::remove(::as_lvalue(stl2::ext::make_range(Iter(ia), Sent(ia+sa))), 2);
CHECK(base(r) == ia + sa-3);
CHECK(ia[0] == 0);
CHECK(ia[1] == 1);
CHECK(ia[2] == 3);
CHECK(ia[3] == 4);
CHECK(ia[4] == 3);
CHECK(ia[5] == 4);
}
void test_rng()
{
int ia[] = {0, 1, 2, 3, 4};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[sa] = {0};
auto rng = ranges::make_iterator_range(InIter(ia), Sent(ia+sa));
std::pair<InIter, OutIter> r = ranges::replace_copy_if(rng, OutIter(ib),
[](int i){return 2==i;}, 5);
CHECK(base(r.first) == ia + sa);
CHECK(base(r.second) == ib + sa);
CHECK(ib[0] == 0);
CHECK(ib[1] == 1);
CHECK(ib[2] == 5);
CHECK(ib[3] == 3);
CHECK(ib[4] == 4);
}
void
test_iter()
{
int ia[] = {0, 1, 2, 3, 4, 2, 3, 4, 2};
constexpr unsigned sa = ranges::size(ia);
int ib[sa];
std::pair<InIter, OutIter> r = ranges::remove_copy_if(InIter(ia), Sent(ia+sa), OutIter(ib), [](int i){return i == 2;});
CHECK(base(r.first) == ia + sa);
CHECK(base(r.second) == ib + sa-3);
CHECK(ib[0] == 0);
CHECK(ib[1] == 1);
CHECK(ib[2] == 3);
CHECK(ib[3] == 4);
CHECK(ib[4] == 3);
CHECK(ib[5] == 4);
}
void tOJDeviceOtherData::OnDataSent()
{
bool success = false;
QNetworkReply* pReply = qobject_cast<QNetworkReply*>( sender() );
if( pReply != 0 )
{
QVariant statusCode = pReply->attribute( QNetworkRequest::HttpStatusCodeAttribute );
if ( statusCode.isValid() )
{
int status = statusCode.toInt();
if ( status != 200 )
{
QString reason = pReply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
ErrorPrintf( QString("%1(): %2 %3").arg(__FUNCTION__).arg(status).arg(reason).toLatin1() );
QString content = pReply->readAll();
ErrorPrintf( QString("%1(): %2").arg(__FUNCTION__).arg(content).toLatin1() );
}
else
{
QString content = pReply->readAll();
tJson json;
bool ok;
QVariantMap result = json.Parse( content, ok ).toMap();
if ( result["OJ_DeviceOtherDataResult"].isValid() == false )
{
DbgPrintf( QString(" error_status = %1").arg(result["error_status"].toInt()) );
DbgPrintf( QString(" language = %1").arg(result["language"].toString()) );
DbgPrintf( QString(" error_message = %1").arg(result["error_message"].toString()) ); }
else
{
QVariantMap nested = result["OJ_DeviceOtherDataResult"].toMap();
success = true;
}
}
}
pReply->deleteLater();
}
emit Sent( success );
}
void
test_iter()
{
test_iter<Iter, Sent>(0);
test_iter<Iter, Sent>(1);
test_iter<Iter, Sent>(2);
test_iter<Iter, Sent>(3);
test_iter<Iter, Sent>(10);
test_iter<Iter, Sent>(1000);
{
const unsigned N = 100;
std::unique_ptr<int[]> a{new int[N]};
std::fill_n(a.get(), N, 5);
std::shuffle(a.get(), a.get()+N, gen);
std::pair<Iter, Iter> p = ranges::minmax_element(Iter(a.get()), Sent(a.get()+N));
CHECK(base(p.first) == a.get());
CHECK(base(p.second) == a.get()+N-1);
}
}
void
test_range_rvalue()
{
constexpr unsigned sa = 9;
std::unique_ptr<int> ia[sa];
ia[0].reset(new int(0));
ia[1].reset(new int(1));
ia[3].reset(new int(3));
ia[4].reset(new int(4));
ia[6].reset(new int(3));
ia[7].reset(new int(4));
Iter r = stl2::remove(::as_lvalue(stl2::ext::make_range(Iter(ia), Sent(ia+sa))), std::unique_ptr<int>());
CHECK(base(r) == ia + sa-3);
CHECK(*ia[0] == 0);
CHECK(*ia[1] == 1);
CHECK(*ia[2] == 3);
CHECK(*ia[3] == 4);
CHECK(*ia[4] == 3);
CHECK(*ia[5] == 4);
}
void test_iter() {
const int ia[] = {0};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ja[sa] = {-1};
count_equal::count = 0;
ranges::unique_copy_result<InIter, OutIter> r =
ranges::unique_copy(InIter(ia), Sent(ia+sa), OutIter(ja), count_equal());
CHECK(base(r.in) == ia + sa);
CHECK(base(r.out) == ja + sa);
CHECK(ja[0] == 0);
CHECK(count_equal::count == sa - 1);
const int ib[] = {0, 1};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
int jb[sb] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ib), Sent(ib+sb), OutIter(jb), count_equal());
CHECK(base(r.in) == ib + sb);
CHECK(base(r.out) == jb + sb);
CHECK(jb[0] == 0);
CHECK(jb[1] == 1);
CHECK(count_equal::count == sb - 1);
const int ic[] = {0, 0};
const unsigned sc = sizeof(ic)/sizeof(ic[0]);
int jc[sc] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ic), Sent(ic+sc), OutIter(jc), count_equal());
CHECK(base(r.in) == ic + sc);
CHECK(base(r.out) == jc + 1);
CHECK(jc[0] == 0);
CHECK(count_equal::count == sc - 1);
const int id[] = {0, 0, 1};
const unsigned sd = sizeof(id)/sizeof(id[0]);
int jd[sd] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(id), Sent(id+sd), OutIter(jd), count_equal());
CHECK(base(r.in) == id + sd);
CHECK(base(r.out) == jd + 2);
CHECK(jd[0] == 0);
CHECK(jd[1] == 1);
CHECK(count_equal::count == sd - 1);
const int ie[] = {0, 0, 1, 0};
const unsigned se = sizeof(ie)/sizeof(ie[0]);
int je[se] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ie), Sent(ie+se), OutIter(je), count_equal());
CHECK(base(r.in) == ie + se);
CHECK(base(r.out) == je + 3);
CHECK(je[0] == 0);
CHECK(je[1] == 1);
CHECK(je[2] == 0);
CHECK(count_equal::count == se - 1);
const int ig[] = {0, 0, 1, 1};
const unsigned sg = sizeof(ig)/sizeof(ig[0]);
int jg[sg] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ig), Sent(ig+sg), OutIter(jg), count_equal());
CHECK(base(r.in) == ig + sg);
CHECK(base(r.out) == jg + 2);
CHECK(jg[0] == 0);
CHECK(jg[1] == 1);
CHECK(count_equal::count == sg - 1);
const int ih[] = {0, 1, 1};
const unsigned sh = sizeof(ih)/sizeof(ih[0]);
int jh[sh] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ih), Sent(ih+sh), OutIter(jh), count_equal());
CHECK(base(r.in) == ih + sh);
CHECK(base(r.out) == jh + 2);
CHECK(jh[0] == 0);
CHECK(jh[1] == 1);
CHECK(count_equal::count == sh - 1);
const int ii[] = {0, 1, 1, 1, 2, 2, 2};
const unsigned si = sizeof(ii)/sizeof(ii[0]);
int ji[si] = {-1};
count_equal::count = 0;
r = ranges::unique_copy(InIter(ii), Sent(ii+si), OutIter(ji), count_equal());
CHECK(base(r.in) == ii + si);
CHECK(base(r.out) == ji + 3);
CHECK(ji[0] == 0);
CHECK(ji[1] == 1);
CHECK(ji[2] == 2);
CHECK(count_equal::count == si - 1);
}
