init
Some checks failed
Docker. / Ubuntu (push) Has been cancelled
User-agent updater. / User-agent (push) Failing after 15s
Lock Threads / lock (push) Failing after 10s
Waiting for answer. / waiting-for-answer (push) Failing after 22s
Needs user action. / needs-user-action (push) Failing after 8s
Can't reproduce. / cant-reproduce (push) Failing after 8s
Close stale issues and PRs / stale (push) Has been cancelled
Some checks failed
Docker. / Ubuntu (push) Has been cancelled
User-agent updater. / User-agent (push) Failing after 15s
Lock Threads / lock (push) Failing after 10s
Waiting for answer. / waiting-for-answer (push) Failing after 22s
Needs user action. / needs-user-action (push) Failing after 8s
Can't reproduce. / cant-reproduce (push) Failing after 8s
Close stale issues and PRs / stale (push) Has been cancelled
This commit is contained in:
allhaileris
854
Telegram/ThirdParty/range-v3/test/algorithm/is_permutation.cpp
vendored
Normal file
854
Telegram/ThirdParty/range-v3/test/algorithm/is_permutation.cpp
vendored
Normal file
@@ -0,0 +1,854 @@
|
||||
// Range v3 library
|
||||
//
|
||||
// Copyright Eric Niebler 2014-present
|
||||
//
|
||||
// Use, modification and distribution is subject to the
|
||||
// Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// Project home: https://github.com/ericniebler/range-v3
|
||||
//
|
||||
// Copyright 2005 - 2007 Adobe Systems Incorporated
|
||||
// Distributed under the MIT License(see accompanying file LICENSE_1_0_0.txt
|
||||
// or a copy at http://stlab.adobe.com/licenses.html)
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <utility>
|
||||
#include <range/v3/core.hpp>
|
||||
#include <range/v3/algorithm/permutation.hpp>
|
||||
#include "../simple_test.hpp"
|
||||
#include "../test_utils.hpp"
|
||||
#include "../test_iterators.hpp"
|
||||
|
||||
RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
|
||||
|
||||
int comparison_count = 0;
|
||||
|
||||
template<typename T>
|
||||
bool counting_equals( T const &a, T const &b )
|
||||
{
|
||||
++comparison_count;
|
||||
return a == b;
|
||||
}
|
||||
|
||||
struct S
|
||||
{
|
||||
int i;
|
||||
};
|
||||
|
||||
struct T
|
||||
{
|
||||
int i;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const int ia[] = {0};
|
||||
const int ib[] = {0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + 0),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0};
|
||||
const int ib[] = {1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
|
||||
{
|
||||
const int ia[] = {0, 0};
|
||||
const int ib[] = {0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0};
|
||||
const int ib[] = {0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0};
|
||||
const int ib[] = {1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0};
|
||||
const int ib[] = {1, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1};
|
||||
const int ib[] = {0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1};
|
||||
const int ib[] = {0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1};
|
||||
const int ib[] = {1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1};
|
||||
const int ib[] = {1, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 0};
|
||||
const int ib[] = {0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 0};
|
||||
const int ib[] = {0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 0};
|
||||
const int ib[] = {1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 0};
|
||||
const int ib[] = {1, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 1};
|
||||
const int ib[] = {0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 1};
|
||||
const int ib[] = {0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 1};
|
||||
const int ib[] = {1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {1, 1};
|
||||
const int ib[] = {1, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 0, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 1, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 1, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 2, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 2, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 0};
|
||||
const int ib[] = {1, 2, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 1};
|
||||
const int ib[] = {1, 0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 1};
|
||||
const int ib[] = {1, 0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2};
|
||||
const int ib[] = {1, 0, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2};
|
||||
const int ib[] = {1, 2, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2};
|
||||
const int ib[] = {2, 1, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2};
|
||||
const int ib[] = {2, 0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 1};
|
||||
const int ib[] = {1, 0, 1};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 0, 1};
|
||||
const int ib[] = {1, 0, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib + 1),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib + 1),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
std::equal_to<const int>()) == false);
|
||||
comparison_count = 0;
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1),
|
||||
counting_equals<const int>) == false);
|
||||
CHECK( comparison_count > 0 );
|
||||
comparison_count = 0;
|
||||
CHECK(ranges::is_permutation(RandomAccessIterator<const int*>(ia),
|
||||
RandomAccessIterator<const int*>(ia + sa),
|
||||
RandomAccessIterator<const int*>(ib),
|
||||
RandomAccessIterator<const int*>(ib + sa - 1),
|
||||
counting_equals<const int>) == false);
|
||||
CHECK ( comparison_count == 0 );
|
||||
}
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<const int>()) == false);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa),
|
||||
std::equal_to<const int>()) == false);
|
||||
}
|
||||
|
||||
// Iterator tests, without predicate:
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib)) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa)) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib + 1),
|
||||
ForwardIterator<const int*>(ib + sa)) == false);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
ForwardIterator<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
ForwardIterator<const int*>(ib + sa - 1)) == false);
|
||||
}
|
||||
|
||||
// Iterator tests, with sentinels:
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib)) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa)) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib + 1),
|
||||
Sentinel<const int*>(ib + sa)) == false);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa),
|
||||
ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa - 1)) == false);
|
||||
}
|
||||
|
||||
// common_range tests, with sentinels:
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ForwardIterator<const int*>(ib)) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa))) == true);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib + 1),
|
||||
Sentinel<const int*>(ib + sa))) == false);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa - 1))) == false);
|
||||
}
|
||||
|
||||
// common_range tests, with sentinels, with predicate:
|
||||
{
|
||||
const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
|
||||
const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ForwardIterator<const int*>(ib),
|
||||
std::equal_to<int const>()) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa)),
|
||||
std::equal_to<int const>()) == true);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib + 1),
|
||||
Sentinel<const int*>(ib + sa)),
|
||||
std::equal_to<int const>()) == false);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
|
||||
Sentinel<const int*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const int*>(ib),
|
||||
Sentinel<const int*>(ib + sa - 1)),
|
||||
std::equal_to<int const>()) == false);
|
||||
}
|
||||
|
||||
// common_range tests, with sentinels, with predicate and projections:
|
||||
{
|
||||
const S ia[] = {{0}, {1}, {2}, {3}, {0}, {5}, {6}, {2}, {4}, {4}};
|
||||
const T ib[] = {{4}, {2}, {3}, {0}, {1}, {4}, {0}, {5}, {6}, {2}};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ia, &ib[0], std::equal_to<int const>(), &S::i, &T::i) == true);
|
||||
CHECK(ranges::is_permutation(ia, ib, std::equal_to<int const>(), &S::i, &T::i) == true);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const T*>(ib + 1),
|
||||
Sentinel<const T*>(ib + sa)),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == false);
|
||||
CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa)),
|
||||
ranges::make_subrange(ForwardIterator<const T*>(ib),
|
||||
Sentinel<const T*>(ib + sa - 1)),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == false);
|
||||
}
|
||||
|
||||
// Iterator tests, with sentinels, with predicate and projections:
|
||||
{
|
||||
const S ia[] = {{0}, {1}, {2}, {3}, {0}, {5}, {6}, {2}, {4}, {4}};
|
||||
const T ib[] = {{4}, {2}, {3}, {0}, {1}, {4}, {0}, {5}, {6}, {2}};
|
||||
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa),
|
||||
ForwardIterator<const T*>(ib),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == true);
|
||||
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa),
|
||||
ForwardIterator<const T*>(ib),
|
||||
Sentinel<const T*>(ib + sa),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == true);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa),
|
||||
ForwardIterator<const T*>(ib + 1),
|
||||
Sentinel<const T*>(ib + sa),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == false);
|
||||
CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
|
||||
Sentinel<const S*>(ia + sa),
|
||||
ForwardIterator<const T*>(ib),
|
||||
Sentinel<const T*>(ib + sa - 1),
|
||||
std::equal_to<int const>(), &S::i, &T::i) == false);
|
||||
}
|
||||
|
||||
return ::test_result();
|
||||
}
|
||||
Reference in New Issue
Block a user