}
template <class GenInputs>
void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) {
- BM_PathConstructIter<input_iterator>(st, gen);
+ BM_PathConstructIter<cpp17_input_iterator>(st, gen);
}
template <class GenInputs>
void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) {
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]);
std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10),
- input_iterator<const int*>(a),
- input_iterator<const int*>(a+N));
+ cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a+N));
assert(false);
}
#endif
{
- typedef input_iterator<int*> MyInputIter;
+ typedef cpp17_input_iterator<int*> MyInputIter;
// Sould not trigger ASan.
std::vector<int> v;
v.reserve(1);
using const_cstr_type = const CharT*;
using array_type = CharT[25];
using const_array_type = const CharT[25];
- using iter_type = input_iterator<CharT*>;
- using bad_iter_type = input_iterator<signed char*>;
+ using iter_type = cpp17_input_iterator<CharT*>;
+ using bad_iter_type = cpp17_input_iterator<signed char*>;
template <class TestT>
static void AssertPathable() {
// iterators in the libc++ test suite
static_assert((!std::__is_cpp17_contiguous_iterator<output_iterator <char *> >::value), "");
- static_assert((!std::__is_cpp17_contiguous_iterator<input_iterator <char *> >::value), "");
+ static_assert((!std::__is_cpp17_contiguous_iterator<cpp17_input_iterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<forward_iterator <char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<bidirectional_iterator<char *> >::value), "");
static_assert((!std::__is_cpp17_contiguous_iterator<random_access_iterator<char *> >::value), "");
TEST_CONSTEXPR_CXX20 bool
test()
{
- test_copy<input_iterator<const int*>, output_iterator<int*> >();
- test_copy<input_iterator<const int*>, forward_iterator<int*> >();
- test_copy<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test_copy<input_iterator<const int*>, random_access_iterator<int*> >();
- test_copy<input_iterator<const int*>, int*>();
+ test_copy<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test_copy<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test_copy<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test_copy<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test_copy<cpp17_input_iterator<const int*>, int*>();
test_copy<forward_iterator<const int*>, output_iterator<int*> >();
test_copy<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy<const int*, int*>();
#if TEST_STD_VER > 17
- test_copy<input_iterator<const int*>, contiguous_iterator<int*>>();
+ test_copy<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test_copy_if<input_iterator<const int*>, output_iterator<int*> >();
- test_copy_if<input_iterator<const int*>, input_iterator<int*> >();
- test_copy_if<input_iterator<const int*>, forward_iterator<int*> >();
- test_copy_if<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test_copy_if<input_iterator<const int*>, random_access_iterator<int*> >();
- test_copy_if<input_iterator<const int*>, int*>();
+ test_copy_if<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test_copy_if<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test_copy_if<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test_copy_if<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test_copy_if<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test_copy_if<cpp17_input_iterator<const int*>, int*>();
test_copy_if<forward_iterator<const int*>, output_iterator<int*> >();
- test_copy_if<forward_iterator<const int*>, input_iterator<int*> >();
+ test_copy_if<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<forward_iterator<const int*>, int*>();
test_copy_if<bidirectional_iterator<const int*>, output_iterator<int*> >();
- test_copy_if<bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test_copy_if<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<bidirectional_iterator<const int*>, int*>();
test_copy_if<random_access_iterator<const int*>, output_iterator<int*> >();
- test_copy_if<random_access_iterator<const int*>, input_iterator<int*> >();
+ test_copy_if<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, forward_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, random_access_iterator<int*> >();
test_copy_if<random_access_iterator<const int*>, int*>();
test_copy_if<const int*, output_iterator<int*> >();
- test_copy_if<const int*, input_iterator<int*> >();
+ test_copy_if<const int*, cpp17_input_iterator<int*> >();
test_copy_if<const int*, forward_iterator<int*> >();
test_copy_if<const int*, bidirectional_iterator<int*> >();
test_copy_if<const int*, random_access_iterator<int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test_copy_n<input_iterator<const int*>, output_iterator<int*> >();
- test_copy_n<input_iterator<const int*>, input_iterator<int*> >();
- test_copy_n<input_iterator<const int*>, forward_iterator<int*> >();
- test_copy_n<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test_copy_n<input_iterator<const int*>, random_access_iterator<int*> >();
- test_copy_n<input_iterator<const int*>, int*>();
+ test_copy_n<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test_copy_n<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test_copy_n<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test_copy_n<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test_copy_n<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test_copy_n<cpp17_input_iterator<const int*>, int*>();
test_copy_n<forward_iterator<const int*>, output_iterator<int*> >();
- test_copy_n<forward_iterator<const int*>, input_iterator<int*> >();
+ test_copy_n<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<forward_iterator<const int*>, int*>();
test_copy_n<bidirectional_iterator<const int*>, output_iterator<int*> >();
- test_copy_n<bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test_copy_n<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<bidirectional_iterator<const int*>, int*>();
test_copy_n<random_access_iterator<const int*>, output_iterator<int*> >();
- test_copy_n<random_access_iterator<const int*>, input_iterator<int*> >();
+ test_copy_n<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, forward_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, random_access_iterator<int*> >();
test_copy_n<random_access_iterator<const int*>, int*>();
test_copy_n<const int*, output_iterator<int*> >();
- test_copy_n<const int*, input_iterator<int*> >();
+ test_copy_n<const int*, cpp17_input_iterator<int*> >();
test_copy_n<const int*, forward_iterator<int*> >();
test_copy_n<const int*, bidirectional_iterator<int*> >();
test_copy_n<const int*, random_access_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
test<const int*, int*>();
#if TEST_STD_VER >= 11
- test1<input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
- test1<input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
- test1<input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
- test1<input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
- test1<input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
test1<forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
#endif // TEST_STD_VER >= 11
#if TEST_STD_VER > 17
- test<input_iterator<const int*>, contiguous_iterator<int*>>();
+ test<cpp17_input_iterator<const int*>, contiguous_iterator<int*>>();
test<forward_iterator<const int*>, contiguous_iterator<int*>>();
test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
test<contiguous_iterator<const int*>, int*>();
test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
- test1<input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+ test1<cpp17_input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
- static_assert(test<input_iterator<const int*>, input_iterator<int*> >());
- static_assert(test<input_iterator<const int*>, forward_iterator<int*> >());
- static_assert(test<input_iterator<const int*>, bidirectional_iterator<int*> >());
- static_assert(test<input_iterator<const int*>, random_access_iterator<int*> >());
- static_assert(test<input_iterator<const int*>, contiguous_iterator<int*> >());
- static_assert(test<input_iterator<const int*>, int*>());
+ static_assert(test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >());
+ static_assert(test<cpp17_input_iterator<const int*>, forward_iterator<int*> >());
+ static_assert(test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >());
+ static_assert(test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >());
+ static_assert(test<cpp17_input_iterator<const int*>, contiguous_iterator<int*> >());
+ static_assert(test<cpp17_input_iterator<const int*>, int*>());
- static_assert(test<forward_iterator<const int*>, input_iterator<int*> >());
+ static_assert(test<forward_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<forward_iterator<const int*>, int*>());
- static_assert(test<bidirectional_iterator<const int*>, input_iterator<int*> >());
+ static_assert(test<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<bidirectional_iterator<const int*>, int*>());
- static_assert(test<random_access_iterator<const int*>, input_iterator<int*> >());
+ static_assert(test<random_access_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<random_access_iterator<const int*>, int*>());
- static_assert(test<contiguous_iterator<const int*>, input_iterator<int*> >());
+ static_assert(test<contiguous_iterator<const int*>, cpp17_input_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
static_assert(test<contiguous_iterator<const int*>, int*>());
- static_assert(test<const int*, input_iterator<int*> >());
+ static_assert(test<const int*, cpp17_input_iterator<int*> >());
static_assert(test<const int*, forward_iterator<int*> >());
static_assert(test<const int*, bidirectional_iterator<int*> >());
static_assert(test<const int*, random_access_iterator<int*> >());
{
const int ia[] = {1, 2, 3, 4, 5, 6};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::end(ia)),
+ assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia)));
{
const int ia[] = {1, 3, 5, 2, 4, 6};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::end(ia)),
+ assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia)));
{
const int ia[] = {2, 4, 6, 1, 3, 5};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::end(ia)),
+ assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia)));
{
const int ia[] = {1, 3, 5, 2, 4, 6, 7};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::end(ia)),
+ assert(!std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia)));
{
const int ia[] = {1, 3, 5, 2, 4, 6, 7};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::begin(ia)),
+ assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::begin(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::begin(ia)));
{
const int ia[] = {1, 3, 5, 7, 9, 11, 2};
unary_counting_predicate<is_odd, int> pred((is_odd()));
- assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
- input_iterator<const int *>(std::end(ia)),
+ assert(std::is_partitioned(cpp17_input_iterator<const int *>(std::begin(ia)),
+ cpp17_input_iterator<const int *>(std::end(ia)),
std::ref(pred)));
assert(static_cast<std::ptrdiff_t>(pred.count()) <=
std::distance(std::begin(ia), std::end(ia)));
int r1[10] = {0};
int r2[10] = {0};
typedef std::pair<output_iterator<int*>, int*> P;
- P p = std::partition_copy(input_iterator<const int*>(std::begin(ia)),
- input_iterator<const int*>(std::end(ia)),
+ P p = std::partition_copy(cpp17_input_iterator<const int*>(std::begin(ia)),
+ cpp17_input_iterator<const int*>(std::end(ia)),
output_iterator<int*>(r1), r2, is_odd());
assert(p.first.base() == r1 + 4);
assert(r1[0] == 1);
// expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
// expected-error@algorithm:* 2 {{does not provide a subscript operator}}
// expected-error@algorithm:* {{invalid operands}}
- test<input_iterator<int *>, output_iterator<int *> >();
+ test<cpp17_input_iterator<int *>, output_iterator<int *> >();
return 0;
}
}
int main(int, char**) {
- test<input_iterator, int, random_access_iterator, int>();
+ test<cpp17_input_iterator, int, random_access_iterator, int>();
test<forward_iterator, int, output_iterator, int>();
test<forward_iterator, int, random_access_iterator, int>();
- test<input_iterator, int, random_access_iterator, double>();
+ test<cpp17_input_iterator, int, random_access_iterator, double>();
test<forward_iterator, int, output_iterator, double>();
test<forward_iterator, int, random_access_iterator, double>();
- test_empty_population<input_iterator, int, random_access_iterator, int>();
+ test_empty_population<cpp17_input_iterator, int, random_access_iterator, int>();
test_empty_population<forward_iterator, int, output_iterator, int>();
test_empty_population<forward_iterator, int, random_access_iterator, int>();
- test_empty_sample<input_iterator, int, random_access_iterator, int>();
+ test_empty_sample<cpp17_input_iterator, int, random_access_iterator, int>();
test_empty_sample<forward_iterator, int, output_iterator, int>();
test_empty_sample<forward_iterator, int, random_access_iterator, int>();
- test_small_population<input_iterator, int, random_access_iterator, int>();
+ test_small_population<cpp17_input_iterator, int, random_access_iterator, int>();
test_small_population<forward_iterator, int, output_iterator, int>();
test_small_population<forward_iterator, int, random_access_iterator, int>();
int main(int, char**) {
test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
- test_stability<input_iterator<int *>, random_access_iterator<int *> >(false);
+ test_stability<cpp17_input_iterator<int *>, random_access_iterator<int *> >(false);
return 0;
}
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<const int*>, int*>();
-
- test<input_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<const int*>, int*>();
-
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
-
- test<input_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<const int*>, int*>();
-
- test<input_iterator<const int*>, const int*, output_iterator<int*> >();
- test<input_iterator<const int*>, const int*, input_iterator<int*> >();
- test<input_iterator<const int*>, const int*, forward_iterator<int*> >();
- test<input_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, const int*, random_access_iterator<int*> >();
- test<input_iterator<const int*>, const int*, int*>();
-
- test<forward_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
+
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*>, int*>();
+
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
+
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*>, int*>();
+
+ test<cpp17_input_iterator<const int*>, const int*, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, const int*, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, const int*, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, const int*, int*>();
+
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
- test<forward_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
+ test<forward_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<const int*>, int*>();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<forward_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test<forward_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<forward_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
- test<forward_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
+ test<forward_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<forward_iterator<const int*>, const int*, output_iterator<int*> >();
- test<forward_iterator<const int*>, const int*, input_iterator<int*> >();
+ test<forward_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, const int*, forward_iterator<int*> >();
test<forward_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<forward_iterator<const int*>, const int*, int*>();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<const int*>, int*>();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, const int*, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, const int*, input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, const int*, int*>();
- test<random_access_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<const int*>, int*>();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
- test<random_access_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
+ test<random_access_iterator<const int*>, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
- test<random_access_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
+ test<random_access_iterator<const int*>, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, const int*, output_iterator<int*> >();
- test<random_access_iterator<const int*>, const int*, input_iterator<int*> >();
+ test<random_access_iterator<const int*>, const int*, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, forward_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, const int*, int*>();
- test<const int*, input_iterator<const int*>, output_iterator<int*> >();
- test<const int*, input_iterator<const int*>, input_iterator<int*> >();
- test<const int*, input_iterator<const int*>, forward_iterator<int*> >();
- test<const int*, input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<const int*, input_iterator<const int*>, random_access_iterator<int*> >();
- test<const int*, input_iterator<const int*>, int*>();
+ test<const int*, cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<const int*>, int*>();
test<const int*, forward_iterator<const int*>, output_iterator<int*> >();
- test<const int*, forward_iterator<const int*>, input_iterator<int*> >();
+ test<const int*, forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, forward_iterator<const int*>, forward_iterator<int*> >();
test<const int*, forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, forward_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, forward_iterator<const int*>, int*>();
test<const int*, bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<const int*, bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test<const int*, bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, bidirectional_iterator<const int*>, int*>();
test<const int*, random_access_iterator<const int*>, output_iterator<int*> >();
- test<const int*, random_access_iterator<const int*>, input_iterator<int*> >();
+ test<const int*, random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, forward_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, random_access_iterator<int*> >();
test<const int*, random_access_iterator<const int*>, int*>();
test<const int*, const int*, output_iterator<int*> >();
- test<const int*, const int*, input_iterator<int*> >();
+ test<const int*, const int*, cpp17_input_iterator<int*> >();
test<const int*, const int*, forward_iterator<int*> >();
test<const int*, const int*, bidirectional_iterator<int*> >();
test<const int*, const int*, random_access_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, input_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, cpp17_input_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
- test<forward_iterator<const int*>, input_iterator<int*> >();
+ test<forward_iterator<const int*>, cpp17_input_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
test<forward_iterator<const int*>, random_access_iterator<int*> >();
test<forward_iterator<const int*>, int*>();
test<bidirectional_iterator<const int*>, output_iterator<int*> >();
- test<bidirectional_iterator<const int*>, input_iterator<int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator<int*> >();
test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
test<bidirectional_iterator<const int*>, int*>();
test<random_access_iterator<const int*>, output_iterator<int*> >();
- test<random_access_iterator<const int*>, input_iterator<int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator<int*> >();
test<random_access_iterator<const int*>, forward_iterator<int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
test<random_access_iterator<const int*>, random_access_iterator<int*> >();
test<random_access_iterator<const int*>, int*>();
test<const int*, output_iterator<int*> >();
- test<const int*, input_iterator<int*> >();
+ test<const int*, cpp17_input_iterator<int*> >();
test<const int*, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
int main(int, char**)
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
{
int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::all_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == true);
- assert(std::all_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == true);
+ assert(std::all_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
+ assert(std::all_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == true);
}
{
const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::all_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == false);
- assert(std::all_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == true);
+ assert(std::all_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
+ assert(std::all_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == true);
}
#if TEST_STD_VER > 17
{
int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == true);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == false);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == false);
}
{
const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == true);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == false);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == false);
}
{
const int ia[] = {1, 3, 5, 7};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == false);
- assert(std::any_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == false);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
+ assert(std::any_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == false);
}
#if TEST_STD_VER > 17
{
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::count(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), 2) == 3);
- assert(std::count(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), 7) == 0);
- assert(std::count(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), 2) == 0);
+ assert(std::count(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), 2) == 3);
+ assert(std::count(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), 7) == 0);
+ assert(std::count(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), 2) == 0);
#if TEST_STD_VER > 17
static_assert(test_constexpr());
{
int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::count_if(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::count_if(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
eq(2)) == 3);
- assert(std::count_if(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::count_if(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
eq(7)) == 0);
- assert(std::count_if(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia),
+ assert(std::count_if(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia),
eq(2)) == 0);
#if TEST_STD_VER > 17
int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7};
- typedef input_iterator<int*> II;
+ typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI;
return !std::equal(std::begin(ia), std::end(ia), std::begin(ic))
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
int ib[s] = {0, 1, 2, 5, 4, 5};
- assert(std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia)));
+ assert(std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia)));
#if TEST_STD_VER >= 14
- assert(std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s)));
+ assert(std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s)));
assert(std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s)));
#endif
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ib)));
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ib)));
#if TEST_STD_VER >= 14
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ib),
- input_iterator<const int*>(ib+s)));
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ib),
+ cpp17_input_iterator<const int*>(ib+s)));
assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ib),
random_access_iterator<const int*>(ib+s)));
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s-1)));
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s-1)));
assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s),
random_access_iterator<const int*>(ia),
int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7};
- typedef input_iterator<int*> II;
+ typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI;
return !std::equal(std::begin(ia), std::end(ia), std::begin(ic) , eq)
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
int ib[s] = {0, 1, 2, 5, 4, 5};
- assert(std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia),
+ assert(std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia),
std::equal_to<int>()));
#if TEST_STD_VER >= 14
- assert(std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
+ assert(std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
std::equal_to<int>()));
assert(std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s),
std::equal_to<int>()));
comparison_count = 0;
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s-1),
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s-1),
counting_equals<int>));
assert(comparison_count > 0);
comparison_count = 0;
counting_equals<int>));
assert(comparison_count == 0);
#endif
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ib),
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ib),
std::equal_to<int>()));
#if TEST_STD_VER >= 14
- assert(!std::equal(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
- input_iterator<const int*>(ib),
- input_iterator<const int*>(ib+s),
+ assert(!std::equal(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*>(ib),
+ cpp17_input_iterator<const int*>(ib+s),
std::equal_to<int>()));
assert(!std::equal(random_access_iterator<const int*>(ia),
random_access_iterator<const int*>(ia+s),
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 3, 5, 7};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ib),
forward_iterator<const int*>(ib + sb)) ==
- input_iterator<const int*>(ia+1));
+ cpp17_input_iterator<const int*>(ia+1));
int ic[] = {7};
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic + 1)) ==
- input_iterator<const int*>(ia+sa));
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ cpp17_input_iterator<const int*>(ia+sa));
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic)) ==
- input_iterator<const int*>(ia+sa));
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+sa));
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic+1)) ==
- input_iterator<const int*>(ia));
+ cpp17_input_iterator<const int*>(ia));
#if TEST_STD_VER > 17
static_assert(test_constexpr());
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
int ib[] = {1, 3, 5, 7};
const unsigned sb = sizeof(ib)/sizeof(ib[0]);
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ib),
forward_iterator<const int*>(ib + sb),
std::equal_to<int>()) ==
- input_iterator<const int*>(ia+1));
+ cpp17_input_iterator<const int*>(ia+1));
int ic[] = {7};
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic + 1),
std::equal_to<int>()) ==
- input_iterator<const int*>(ia+sa));
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa),
+ cpp17_input_iterator<const int*>(ia+sa));
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic),
std::equal_to<int>()) ==
- input_iterator<const int*>(ia+sa));
- assert(std::find_first_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+sa));
+ assert(std::find_first_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia),
forward_iterator<const int*>(ic),
forward_iterator<const int*>(ic+1),
std::equal_to<int>()) ==
- input_iterator<const int*>(ia));
+ cpp17_input_iterator<const int*>(ia));
#if TEST_STD_VER > 17
static_assert(test_constexpr());
{
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
- input_iterator<const int*> r = std::find(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s), 3);
+ cpp17_input_iterator<const int*> r = std::find(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s), 3);
assert(*r == 3);
- r = std::find(input_iterator<const int*>(ia), input_iterator<const int*>(ia+s), 10);
- assert(r == input_iterator<const int*>(ia+s));
+ r = std::find(cpp17_input_iterator<const int*>(ia), cpp17_input_iterator<const int*>(ia+s), 10);
+ assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17
static_assert(test_constexpr());
{
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
- input_iterator<const int*> r = std::find_if(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*> r = std::find_if(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
eq(3));
assert(*r == 3);
- r = std::find_if(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
+ r = std::find_if(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
eq(10));
- assert(r == input_iterator<const int*>(ia+s));
+ assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17
static_assert(test_constexpr());
{
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
- input_iterator<const int*> r = std::find_if_not(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
+ cpp17_input_iterator<const int*> r = std::find_if_not(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
ne(3));
assert(*r == 3);
- r = std::find_if_not(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia+s),
+ r = std::find_if_not(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia+s),
ne(10));
- assert(r == input_iterator<const int*>(ia+s));
+ assert(r == cpp17_input_iterator<const int*>(ia+s));
#if TEST_STD_VER > 17
static_assert(test_constexpr());
int main(int, char**)
{
- typedef input_iterator<int*> Iter;
+ typedef cpp17_input_iterator<int*> Iter;
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
{
int ia[] = {0, 1, 2, 3, 4, 5};
const unsigned s = sizeof(ia)/sizeof(ia[0]);
- for_each_test f = std::for_each(input_iterator<int*>(ia),
- input_iterator<int*>(ia+s),
+ for_each_test f = std::for_each(cpp17_input_iterator<int*>(ia),
+ cpp17_input_iterator<int*>(ia+s),
for_each_test(0));
assert(f.count == s);
for (unsigned i = 0; i < s; ++i)
{
int ia[] = {2, 4, 6, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == false);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == true);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == true);
}
{
const int ia[] = {2, 4, 5, 8};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == false);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == true);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == false);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == true);
}
{
const int ia[] = {1, 3, 5, 7};
const unsigned sa = sizeof(ia)/sizeof(ia[0]);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia + sa), test1()) == true);
- assert(std::none_of(input_iterator<const int*>(ia),
- input_iterator<const int*>(ia), test1()) == true);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia + sa), test1()) == true);
+ assert(std::none_of(cpp17_input_iterator<const int*>(ia),
+ cpp17_input_iterator<const int*>(ia), test1()) == true);
}
#if TEST_STD_VER > 17
int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7};
- typedef input_iterator<int*> II;
+ typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI;
auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic));
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
- typedef input_iterator<const int*> II;
+ typedef cpp17_input_iterator<const int*> II;
typedef random_access_iterator<const int*> RAI;
assert(std::mismatch(II(ia), II(ia + sa), II(ib))
int ia[] = {1, 3, 6, 7};
int ib[] = {1, 3};
int ic[] = {1, 3, 5, 7};
- typedef input_iterator<int*> II;
+ typedef cpp17_input_iterator<int*> II;
typedef bidirectional_iterator<int*> BI;
auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), eq);
int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
- typedef input_iterator<const int*> II;
+ typedef cpp17_input_iterator<const int*> II;
typedef random_access_iterator<const int*> RAI;
typedef std::equal_to<int> EQ;
int main(int, char**)
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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*> >();
int main(int, char**)
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
int main(int, char**) {
int arr[] = {1, 2, 3};
const int *b = std::begin(arr), *e = std::end(arr);
- typedef input_iterator<const int*> Iter;
+ typedef cpp17_input_iterator<const int*> Iter;
{
// expected-error@algorithm:* {{"std::min_element requires a ForwardIterator"}}
std::min_element(Iter(b), Iter(e));
TEST_CONSTEXPR_CXX20
bool do_tests()
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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_CONSTEXPR_CXX20
bool do_tests()
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
template<class T, class Iter1>
TEST_CONSTEXPR_CXX20 void test2()
{
- test3<T, Iter1, input_iterator<const T*> >();
+ test3<T, Iter1, cpp17_input_iterator<const T*> >();
test3<T, Iter1, forward_iterator<const T*> >();
test3<T, Iter1, bidirectional_iterator<const T*> >();
test3<T, Iter1, random_access_iterator<const T*> >();
template<class T>
TEST_CONSTEXPR_CXX20 void test1()
{
- test2<T, input_iterator<const T*> >();
+ test2<T, cpp17_input_iterator<const T*> >();
test2<T, forward_iterator<const T*> >();
test2<T, bidirectional_iterator<const T*> >();
test2<T, random_access_iterator<const T*> >();
P(3, 2),
};
M m;
- m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(m.begin()->first == 1);
assert(m.begin()->second == 1);
P(3, 2),
};
M m;
- m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(m.begin()->first == 1);
assert(m.begin()->second == 1);
P(3, 2),
};
M m;
- m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(m.begin()->first == 1);
assert(m.begin()->second == 1);
P(3, 2),
};
M m;
- m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<P*>(ar), cpp17_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(m.begin()->first == 1);
assert(m.begin()->second == 1);
3
};
M m;
- m.insert(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1);
3
};
M m;
- m.insert(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(*next(m.begin(), 0) == 1);
assert(*next(m.begin(), 1) == 1);
3,
3
};
- std::multiset<V> m(input_iterator<const int*>(ar),
- input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+ std::multiset<V> m(cpp17_input_iterator<const int*>(ar),
+ cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1);
3,
3
};
- std::multiset<V, std::less<V>, min_allocator<V>> m(input_iterator<const int*>(ar),
- input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+ std::multiset<V, std::less<V>, min_allocator<V>> m(cpp17_input_iterator<const int*>(ar),
+ cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9);
assert(*next(m.begin(), 0) == 1);
};
typedef test_compare<std::less<V> > C;
typedef test_allocator<V> A;
- std::multiset<V, C, A> m(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
+ std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7));
assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7));
3
};
typedef test_compare<std::less<V> > C;
- std::multiset<V, C> m(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
+ std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5));
assert(m.size() == 9);
assert(distance(m.begin(), m.end()) == 9);
3
};
M m;
- m.insert(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(*m.begin() == 1);
assert(*next(m.begin()) == 2);
3
};
M m;
- m.insert(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+ m.insert(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(*m.begin() == 1);
assert(*next(m.begin()) == 2);
3,
3
};
- std::set<V> m(input_iterator<const int*>(ar),
- input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+ std::set<V> m(cpp17_input_iterator<const int*>(ar),
+ cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1);
3,
3
};
- std::set<V, std::less<int>, min_allocator<int>> m(input_iterator<const int*>(ar),
- input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+ std::set<V, std::less<int>, min_allocator<int>> m(cpp17_input_iterator<const int*>(ar),
+ cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
assert(*m.begin() == 1);
};
typedef test_compare<std::less<V> > C;
typedef test_allocator<V> A;
- std::set<V, C, A> m(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
+ std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
C(5), A(7));
assert(m.value_comp() == C(5));
assert(m.get_allocator() == A(7));
3
};
typedef test_compare<std::less<V> > C;
- std::set<V, C> m(input_iterator<const V*>(ar),
- input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
+ std::set<V, C> m(cpp17_input_iterator<const V*>(ar),
+ cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
assert(m.value_comp() == C(5));
assert(m.size() == 3);
assert(distance(m.begin(), m.end()) == 3);
testI(C& c1, const C& c2)
{
typedef typename C::const_iterator CI;
- typedef input_iterator<CI> ICI;
+ typedef cpp17_input_iterator<CI> ICI;
c1.assign(ICI(c2.begin()), ICI(c2.end()));
assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
assert(c1 == c2);
}
{
using T = EmplaceConstructibleMoveableAndAssignable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
std::deque<T> v;
v.assign(It(arr1), It(std::end(arr1)));
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
- test(input_iterator<const int*>(ab), input_iterator<const int*>(an));
+ test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an));
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an));
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
}
{
using T = EmplaceConstructibleAndMoveable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
std::deque<T> v(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0);
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
- test(input_iterator<const int*>(ab), input_iterator<const int*>(an), test_allocator<int>(3));
+ test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an), test_allocator<int>(3));
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4));
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5));
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6));
#if TEST_STD_VER >= 11
- test(input_iterator<const int*>(ab), input_iterator<const int*>(an), min_allocator<int>());
+ test(cpp17_input_iterator<const int*>(ab), cpp17_input_iterator<const int*>(an), min_allocator<int>());
test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>());
test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>());
test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>());
}
{
using T = EmplaceConstructibleAndMoveable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
std::allocator<T> a;
{
std::deque<T> v(It(arr1), It(std::end(arr1)), a);
{
{
typedef typename C::const_iterator CI;
- typedef input_iterator<CI> BCI;
+ typedef cpp17_input_iterator<CI> BCI;
C c1 = c0;
std::size_t c1_osize = c1.size();
CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
testI(int P, C& c1, const C& c2)
{
typedef typename C::const_iterator CI;
- typedef input_iterator<CI> ICI;
+ typedef cpp17_input_iterator<CI> ICI;
std::size_t c1_osize = c1.size();
CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
assert(i == c1.begin() + P);
assert(*i == MoveOnly(j));
{
MoveOnly mo(1);
- typedef input_iterator<MoveOnly*> I;
+ typedef cpp17_input_iterator<MoveOnly*> I;
c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1)));
}
j = 0;
typedef typename C::const_iterator CI;
typedef random_access_iterator<I> RAI;
typedef random_access_iterator<CI> RACI;
- typedef input_iterator<CI> ICI;
+ typedef cpp17_input_iterator<CI> ICI;
C c1 = make<C>(N, start);
C c2 = make<C>(N);
assert(std::copy(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const T t1[] = {10, 11, 12, 13};
C c(std::begin(t1), std::end(t1));
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
const T t0[] = {10, 11, 12, 13};
const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(std::begin(t1), std::end(t1));
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const T t1[] = {10, 11, 12, 13};
C c(std::begin(t1), std::end(t1));
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
const T t0[] = {10, 11, 12, 13};
const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(std::begin(t1), std::end(t1));
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
c.assign(I(std::begin(t0)), I(std::end(t0)));
int n = 0;
for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, (void) ++n)
{
typedef int T;
typedef std::forward_list<T> C;
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)));
int n = 0;
{
typedef int T;
typedef std::forward_list<T, min_allocator<T>> C;
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)));
int n = 0;
typedef int T;
typedef test_allocator<T> A;
typedef std::forward_list<T, A> C;
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)), A(13));
int n = 0;
typedef int T;
typedef min_allocator<T> A;
typedef std::forward_list<T, A> C;
- typedef input_iterator<const T*> I;
+ typedef cpp17_input_iterator<const T*> I;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(I(std::begin(t)), I(std::end(t)), A());
int n = 0;
typedef int T;
typedef std::forward_list<T> C;
typedef C::iterator I;
- typedef input_iterator<const T*> J;
+ typedef cpp17_input_iterator<const T*> J;
C c;
const T t[] = {0, 1, 2, 3, 4};
I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
typedef int T;
typedef std::forward_list<T, min_allocator<T>> C;
typedef C::iterator I;
- typedef input_iterator<const T*> J;
+ typedef cpp17_input_iterator<const T*> J;
C c;
const T t[] = {0, 1, 2, 3, 4};
I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
{
{
int a[] = {0, 1, 2, 3};
- std::list<int> l(input_iterator<const int*>(a),
- input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+ std::list<int> l(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0;
}
{
int a[] = {0, 1, 2, 3};
- std::list<int> l(input_iterator<const int*>(a),
- input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
+ std::list<int> l(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
std::allocator<int>());
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
{
int a[] = {0, 1, 2, 3};
// Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
- std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(input_iterator<const int*>(a),
- input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+ std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0;
#if TEST_STD_VER >= 11
{
int a[] = {0, 1, 2, 3};
- std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
- input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+ std::list<int, min_allocator<int>> l(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0;
}
{
int a[] = {0, 1, 2, 3};
- std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
- input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
+ std::list<int, min_allocator<int>> l(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
min_allocator<int>());
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
}
{
using T = EmplaceConstructible<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
std::list<T> v(It(arr1), It(std::end(arr1)));
auto I = v.begin();
}
{
using T = EmplaceConstructible<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
std::allocator<T> a;
{
std::list<T> v(It(arr1), It(std::end(arr1)), a);
}
{
using C = TCT::list<>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1)));
}
{
using C = TCT::list<>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
using Alloc = typename C::allocator_type;
Alloc a;
{
{
bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
bool* an = a + sizeof(a)/sizeof(a[0]);
- test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
+ test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
test<std::vector<bool> >(a, an);
#if TEST_STD_VER >= 11
- test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
+ test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
bool* an = a + sizeof(a)/sizeof(a[0]);
{
std::allocator<bool> alloc;
- test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
+ test<std::vector<bool> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
#if TEST_STD_VER >= 11
{
min_allocator<bool> alloc;
- test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
+ test<std::vector<bool, min_allocator<bool>> >(cpp17_input_iterator<const bool*>(a), cpp17_input_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
std::vector<bool> v(100);
bool a[] = {1, 0, 0, 1, 1};
const unsigned N = sizeof(a)/sizeof(a[0]);
- std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
- input_iterator<const bool*>(a+N));
+ std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
+ cpp17_input_iterator<const bool*>(a+N));
assert(v.size() == 100 + N);
assert(i == v.begin() + 10);
std::size_t j;
std::vector<bool, min_allocator<bool>> v(100);
bool a[] = {1, 0, 0, 1, 1};
const unsigned N = sizeof(a)/sizeof(a[0]);
- std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
- input_iterator<const bool*>(a+N));
+ std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
+ cpp17_input_iterator<const bool*>(a+N));
assert(v.size() == 100 + N);
assert(i == v.begin() + 10);
std::size_t j;
}
{
using T = EmplaceConstructibleMoveableAndAssignable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
std::vector<T> v;
v.assign(It(arr1), It(std::end(arr1)));
static void basic_test_cases() {
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
int* an = a + sizeof(a) / sizeof(a[0]);
- test<std::vector<int> >(input_iterator<const int*>(a),
- input_iterator<const int*>(an));
+ test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(an));
test<std::vector<int> >(forward_iterator<const int*>(a),
forward_iterator<const int*>(an));
test<std::vector<int> >(bidirectional_iterator<const int*>(a),
test<std::vector<int> >(a, an);
test<std::vector<int, limited_allocator<int, 63> > >(
- input_iterator<const int*>(a), input_iterator<const int*>(an));
+ cpp17_input_iterator<const int*>(a), cpp17_input_iterator<const int*>(an));
// Add 1 for implementations that dynamically allocate a container proxy.
test<std::vector<int, limited_allocator<int, 18 + 1> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an));
random_access_iterator<const int*>(an));
test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
#if TEST_STD_VER >= 11
- test<std::vector<int, min_allocator<int> > >(input_iterator<const int*>(a),
- input_iterator<const int*>(an));
+ test<std::vector<int, min_allocator<int> > >(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an));
test<std::vector<int, min_allocator<int> > >(
}
{
using T = EmplaceConstructibleAndMoveInsertable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
std::vector<T> v(It(arr1), It(std::end(arr1)));
assert(v[0].copied == 0);
}
{
using C = TCT::vector<>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
{
ExpectConstructGuard<int&> G(1);
C v(It(arr1), It(std::end(arr1)));
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
int* an = a + sizeof(a) / sizeof(a[0]);
std::allocator<int> alloc;
- test<std::vector<int> >(input_iterator<const int*>(a),
- input_iterator<const int*>(an), alloc);
+ test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(an), alloc);
test<std::vector<int> >(forward_iterator<const int*>(a),
forward_iterator<const int*>(an), alloc);
test<std::vector<int> >(bidirectional_iterator<const int*>(a),
int* an = a + sizeof(a) / sizeof(a[0]);
min_allocator<int> alloc;
test<std::vector<int, min_allocator<int> > >(
- input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
+ cpp17_input_iterator<const int*>(a), cpp17_input_iterator<const int*>(an), alloc);
test<std::vector<int, min_allocator<int> > >(
forward_iterator<const int*>(a), forward_iterator<const int*>(an),
alloc);
}
{
using T = EmplaceConstructibleAndMoveInsertable<int>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
using Alloc = std::allocator<T>;
Alloc a;
{
}
{
using C = TCT::vector<>;
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
using Alloc = typename C::allocator_type;
Alloc a;
{
V v(100);
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]);
- V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
- input_iterator<const int*>(a+N));
+ V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
V v(100);
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]);
- V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
- input_iterator<const int*>(a+N));
+ V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
V v(100);
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]);
- V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
- input_iterator<const int*>(a+N));
+ V::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const int*>(a),
+ cpp17_input_iterator<const int*>(a+N));
assert(v.size() == 100 + N);
assert(is_contiguous_container_asan_correct(v));
assert(i == v.begin() + 10);
{
std::vector<adl::S> s;
- s.insert(s.end(), input_iterator<adl::S*>(), input_iterator<adl::S*>());
+ s.insert(s.end(), cpp17_input_iterator<adl::S*>(), cpp17_input_iterator<adl::S*>());
}
return 0;
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
assert(c.at(1) == "one");
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
assert(c.at(1) == "one");
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14);
+ C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14);
assert(c.bucket_count() >= 14);
assert(c.size() == 4);
assert(c.at(1) == "one");
};
HF hf(42);
A a(43);
- C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a);
+ C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a);
assert(c.bucket_count() >= 14);
assert(c.size() == 4);
assert(c.at(1) == "one");
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10
);
LIBCPP_ASSERT(c.bucket_count() == 11);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10
);
LIBCPP_ASSERT(c.bucket_count() == 11);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(2, "four"),
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
P(2, "four"),
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4);
assert(c.at(1) == "one");
assert(c.at(2) == "two");
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
P(2, "four"),
};
A a(42);
- C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
+ C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
assert(c.bucket_count() >= 14);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
};
A a(42);
HF hf (43);
- C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
+ C c(cpp17_input_iterator<P*>(arr), cpp17_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
assert(c.bucket_count() >= 12);
assert(c.size() == 6);
typedef std::pair<C::const_iterator, C::const_iterator> Eq;
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10
);
LIBCPP_ASSERT(c.bucket_count() == 11);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10
);
LIBCPP_ASSERT(c.bucket_count() == 11);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1, "four"),
P(2, "four"),
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(2, "four"),
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6);
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
P(2, "four"),
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6);
typedef std::pair<C::iterator, C::iterator> Eq;
Eq eq = c.equal_range(1);
P(2)
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6);
assert(c.count(1) == 2);
assert(c.count(2) == 2);
P(2)
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 6);
assert(c.count(1) == 2);
assert(c.count(2) == 2);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
assert(c.count(1) == 2);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
assert(c.count(1) == 2);
T(2)
};
A a(42);
- C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
+ C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
assert(c.bucket_count() >= 12);
assert(c.size() == 6);
assert(c.count(1) == 2);
};
HF hf(43);
A a(42);
- C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
+ C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
assert(c.bucket_count() >= 16);
assert(c.size() == 6);
assert(c.count(1) == 2);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7
);
LIBCPP_ASSERT(c.bucket_count() == 7);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7
);
LIBCPP_ASSERT(c.bucket_count() == 7);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(2)
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
P(2)
};
C c;
- c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ c.insert(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.size() == 4);
assert(c.count(1) == 1);
assert(c.count(2) == 1);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
assert(c.count(1) == 1);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
assert(c.count(1) == 1);
T(2)
};
A a(42);
- C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
+ C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
assert(c.bucket_count() >= 12);
assert(c.size() == 4);
assert(c.count(1) == 1);
};
HF hf(43);
A a(42);
- C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
+ C c(cpp17_input_iterator<T*>(arr), cpp17_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
assert(c.bucket_count() >= 16);
assert(c.size() == 4);
assert(c.count(1) == 1);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7
);
LIBCPP_ASSERT(c.bucket_count() == 7);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7
);
LIBCPP_ASSERT(c.bucket_count() == 7);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8)
);
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9)
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
P(1),
P(2)
};
- C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+ C c(cpp17_input_iterator<P*>(a), cpp17_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7,
test_hash<std::hash<int> >(8),
test_compare<std::equal_to<int> >(9),
test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
test('x', ints, ints+10, "10x11x12x13x14x15x16x17x18x19");
- test('X', input_iterator<const char*>(chars), input_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
- test('x', input_iterator<const int*>(ints), input_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
+ test('X', cpp17_input_iterator<const char*>(chars), cpp17_input_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
+ test('x', cpp17_input_iterator<const int*>(ints), cpp17_input_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
test('X', forward_iterator<const char*>(chars), forward_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
test('x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), "10x11x12x13x14x15x16x17x18x19");
test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
const int ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
test(L'x', ints, ints+10, L"10x11x12x13x14x15x16x17x18x19");
- test(L'X', input_iterator<const wchar_t*>(chars), input_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
- test(L'x', input_iterator<const int*>(ints), input_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
+ test(L'X', cpp17_input_iterator<const wchar_t*>(chars), cpp17_input_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
+ test(L'x', cpp17_input_iterator<const int*>(ints), cpp17_input_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
test(L'X', forward_iterator<const wchar_t*>(chars), forward_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
test(L'x', forward_iterator<const int*>(ints), forward_iterator<const int*>(ints+10), L"10x11x12x13x14x15x16x17x18x19");
test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
using Ptr = CharT const*;
using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>;
- using InputIter = input_iterator<Ptr>;
+ using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs;
Str RShort = (Ptr)TC.rhs;
using Ptr = CharT const*;
using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>;
- using InputIter = input_iterator<Ptr>;
+ using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs;
const Ptr R = TC.rhs;
const Ptr E = TC.expected_result();
static_assert(has_append<It>(), "");
}
{
- using It = input_iterator<const char*>;
+ using It = cpp17_input_iterator<const char*>;
static_assert(has_append<It>(), "");
}
{
using reference = const char&;
using difference_type = std::ptrdiff_t;
};
- using It = input_iterator<const char*, Traits>;
+ using It = cpp17_input_iterator<const char*, Traits>;
static_assert(has_append<It>(), "");
}
{
//////////////////////////////////////////////////////////////////////////////
// Iterators
{
- using It = input_iterator<const CharT*>;
+ using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1);
It it(TestPath);
{
assert(p.string<CharT>() == TestPath);
}
{
- using It = input_iterator<const CharT*>;
+ using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1);
It it(TestPath);
{
assert(p.string<CharT>() == TestPath);
}
{
- using It = input_iterator<const CharT*>;
+ using It = cpp17_input_iterator<const CharT*>;
path p; PathReserve(p, Size + 1);
It it(TestPath);
It e(TestPathEnd);
static_assert(has_assign<It>(), "");
}
{
- using It = input_iterator<const char*>;
+ using It = cpp17_input_iterator<const char*>;
static_assert(std::is_assignable<path, It>::value, "");
static_assert(has_assign<It>(), "");
}
using reference = const char&;
using difference_type = std::ptrdiff_t;
};
- using It = input_iterator<const char*, Traits>;
+ using It = cpp17_input_iterator<const char*, Traits>;
static_assert(std::is_assignable<path, It>::value, "");
static_assert(has_assign<It>(), "");
}
using Ptr = CharT const*;
using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>;
- using InputIter = input_iterator<Ptr>;
+ using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs;
const Ptr R = TC.rhs;
using Ptr = CharT const*;
using Str = std::basic_string<CharT>;
using StrView = std::basic_string_view<CharT>;
- using InputIter = input_iterator<Ptr>;
+ using InputIter = cpp17_input_iterator<Ptr>;
const Ptr L = TC.lhs;
const Ptr R = TC.rhs;
const Ptr E = TC.expect;
static_assert(has_concat<It>(), "");
}
{
- using It = input_iterator<const char*>;
+ using It = cpp17_input_iterator<const char*>;
static_assert(has_concat<It>(), "");
}
{
using reference = const char&;
using difference_type = std::ptrdiff_t;
};
- using It = input_iterator<const char*, Traits>;
+ using It = cpp17_input_iterator<const char*, Traits>;
static_assert(has_concat<It>(), "");
}
{
}
// Iterators
{
- using It = input_iterator<const CharT*>;
+ using It = cpp17_input_iterator<const CharT*>;
path p(It{TestPath}, args...);
assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath);
}
{
- using It = input_iterator<const CharT*>;
+ using It = cpp17_input_iterator<const CharT*>;
path p(It{TestPath}, It{TestPathEnd}, args...);
assert(p.native() == Expect);
assert(p.string<CharT>() == TestPath);
static_assert(std::is_constructible<path, It>::value, "");
}
{
- using It = input_iterator<const char*>;
+ using It = cpp17_input_iterator<const char*>;
static_assert(std::is_constructible<path, It>::value, "");
}
{
using reference = const char&;
using difference_type = std::ptrdiff_t;
};
- using It = input_iterator<const char*, Traits>;
+ using It = cpp17_input_iterator<const char*, Traits>;
static_assert(std::is_constructible<path, It>::value, "");
}
{
{
const char* s = "1234567890";
typedef std::iterator_traits<const char*>::difference_type Distance;
- check_advance<Distance>(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10));
+ check_advance<Distance>(cpp17_input_iterator<const char*>(s), 10, cpp17_input_iterator<const char*>(s+10));
check_advance<Distance>(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
check_advance<Distance>(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10));
check_advance<Distance>(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s));
check_advance<Distance>(s+5, -5, s);
// Also check with other distance types
- check_advance<std::size_t>(input_iterator<const char*>(s), 10u, input_iterator<const char*>(s+10));
+ check_advance<std::size_t>(cpp17_input_iterator<const char*>(s), 10u, cpp17_input_iterator<const char*>(s+10));
check_advance<std::size_t>(forward_iterator<const char*>(s), 10u, forward_iterator<const char*>(s+10));
check_advance<std::size_t>(bidirectional_iterator<const char*>(s), 10u, bidirectional_iterator<const char*>(s+10));
check_advance<std::size_t>(random_access_iterator<const char*>(s), 10u, random_access_iterator<const char*>(s+10));
TEST_CONSTEXPR_CXX17 bool tests()
{
const char* s = "1234567890";
- check_distance(input_iterator<const char*>(s), input_iterator<const char*>(s+10), 10);
+ check_distance(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), 10);
check_distance(forward_iterator<const char*>(s), forward_iterator<const char*>(s+10), 10);
check_distance(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+10), 10);
check_distance(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+10), 10);
TEST_CONSTEXPR_CXX17 bool tests()
{
const char* s = "1234567890";
- check_next_n(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10));
+ check_next_n(cpp17_input_iterator<const char*>(s), 10, cpp17_input_iterator<const char*>(s+10));
check_next_n(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
check_next_n(bidirectional_iterator<const char*>(s), 10, bidirectional_iterator<const char*>(s+10));
check_next_n(bidirectional_iterator<const char*>(s+10), -10, bidirectional_iterator<const char*>(s));
check_next_n(random_access_iterator<const char*>(s+10), -10, random_access_iterator<const char*>(s));
check_next_n(s, 10, s+10);
- check_next_1(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
+ check_next_1(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
check_next_1(forward_iterator<const char*>(s), forward_iterator<const char*>(s+1));
check_next_1(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1));
check_next_1(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1));
// Other test iterators.
-using InputTestItereatorTraits = std::iterator_traits<input_iterator<int*> >;
+using InputTestItereatorTraits = std::iterator_traits<cpp17_input_iterator<int*> >;
static_assert(std::same_as<InputTestItereatorTraits::iterator_category,
std::input_iterator_tag>);
static_assert(std::same_as<InputTestItereatorTraits::value_type, int>);
#include "test_iterators.h"
-static_assert(std::same_as<std::iter_reference_t<input_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<cpp17_input_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<forward_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<bidirectional_iterator<int*> >, int&>);
static_assert(std::same_as<std::iter_reference_t<random_access_iterator<int*> >, int&>);
#include "test_iterators.h"
-static_assert(std::input_iterator<input_iterator<int*> >);
+static_assert(std::input_iterator<cpp17_input_iterator<int*> >);
static_assert(std::input_iterator<cpp20_input_iterator<int*> >);
struct no_explicit_iter_concept {
static_assert(std::input_or_output_iterator<int volatile*>);
static_assert(std::input_or_output_iterator<int const volatile*>);
-static_assert(std::input_or_output_iterator<input_iterator<int*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int const*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int volatile*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int const volatile*> >);
+static_assert(std::input_or_output_iterator<cpp17_input_iterator<int*> >);
+static_assert(std::input_or_output_iterator<cpp17_input_iterator<int const*> >);
+static_assert(std::input_or_output_iterator<cpp17_input_iterator<int volatile*> >);
+static_assert(std::input_or_output_iterator<cpp17_input_iterator<int const volatile*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int*> >);
static_assert(std::input_or_output_iterator<forward_iterator<int const*> >);
{
{
char s[] = "1234567890";
- test(input_iterator<char*>(s+5));
+ test(cpp17_input_iterator<char*>(s+5));
test(forward_iterator<char*>(s+5));
test(bidirectional_iterator<char*>(s+5));
test(random_access_iterator<char*>(s+5));
int main(int, char**)
{
char s[] = "1234567890";
- test(input_iterator<char*>(s), input_iterator<char*>(s), true);
- test(input_iterator<char*>(s), input_iterator<char*>(s+1), false);
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s), true);
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), false);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), true);
int main(int, char**)
{
char s[] = "1234567890";
- test(input_iterator<char*>(s), input_iterator<char*>(s), false);
- test(input_iterator<char*>(s), input_iterator<char*>(s+1), true);
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s), false);
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1), true);
test(forward_iterator<char*>(s), forward_iterator<char*>(s), false);
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), true);
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), false);
{
Derived d;
- test<input_iterator<Base*> >(input_iterator<Derived*>(&d));
+ test<cpp17_input_iterator<Base*> >(cpp17_input_iterator<Derived*>(&d));
test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
int main(int, char**)
{
- test<input_iterator<char*> >();
+ test<cpp17_input_iterator<char*> >();
test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >();
int main(int, char**)
{
char s[] = "123";
- test(input_iterator<char*>(s));
+ test(cpp17_input_iterator<char*>(s));
test(forward_iterator<char*>(s));
test(bidirectional_iterator<char*>(s));
test(random_access_iterator<char*>(s));
{
char s[] = "123";
#if TEST_STD_VER > 17
- test_single_pass(input_iterator<char*>(s), input_iterator<char*>(s + 1));
+ test_single_pass(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s + 1));
#else
- test(input_iterator<char*>(s), input_iterator<char*>(s+1));
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1));
#endif
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
int main(int, char**)
{
char s[] = "123";
- test(input_iterator<char*>(s), input_iterator<char*>(s+1));
+ test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1));
test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
{
Derived d;
- test<input_iterator<Base*> >(input_iterator<Derived*>(&d));
+ test<cpp17_input_iterator<Base*> >(cpp17_input_iterator<Derived*>(&d));
test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
int main(int, char**)
{
- test<input_iterator<char*> >();
+ test<cpp17_input_iterator<char*> >();
test<forward_iterator<char*> >();
test<bidirectional_iterator<char*> >();
test<random_access_iterator<char*> >();
#include "platform_support.h" // locale name macros
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet
: public Fn
: Fn(refs) {}
};
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw
: public Fw
// char, national
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "$0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "$0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-$0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-$0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "$1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// char, international
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "USD 0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "USD 0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-USD 0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-USD 0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "USD 1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-$1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, national
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"$0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"$0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-$0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-$0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"$1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, international
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"USD 0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"USD 0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-USD 0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-USD 0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"USD 1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#include "platform_support.h" // locale name macros
#include "test_macros.h"
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet
: public Fn
: Fn(refs) {}
};
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw
: public Fw
// char, national
{ // zero
std::string v = "0,00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0,01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1 234 567,89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567,89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-0,01 \u20ac"; // EURO SIGN
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-0,01 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "1 234 567,89 \u20ac"; // EURO SIGN
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "1 234 567,89 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "1 234 567,89 EUR -";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "1 234 567,89 EUR -";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// char, international
{ // zero
std::string v = "0,00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0,01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1 234 567,89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567,89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 EUR";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 EUR";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-0,01 EUR";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-0,01 EUR";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "1 234 567,89 EUR";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "1 234 567,89 EUR";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 EUR";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "1 234 567,89 Eu-";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "1 234 567,89 Eu-";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, national
{ // zero
std::wstring v = L"0,00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0,01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = convert_thousands_sep(L"-1 234 567,89");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567,89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-0,01 \u20ac"; // EURO SIGN
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-0,01 \u20ac"; // EURO SIGN
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac"); // EURO SIGN
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"-1 234 567,89 \u20ac"); // EURO SIGN
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, international
{ // zero
std::wstring v = L"0,00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0,01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = convert_thousands_sep(L"-1 234 567,89");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567,89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 EUR";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 EUR";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-0,01 EUR";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-0,01 EUR";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"-1 234 567,89 EUR");
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
# define APPLE_FIXME
#endif
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet
: public Fn
: Fn(refs) {}
};
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw
: public Fw
// char, national
{ // zero
std::string v = "0,00 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0,01 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-1 234 567,89 RUB ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// char, international
{ // zero
std::string v = "0,00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0,01 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1 234 567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567,89 ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "0,00 RUB ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "0,00 RUB ";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#endif
{ // negative one, showbase
std::string v = "-0,01 RUB ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-0,01 RUB ";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#endif
{ // positive, showbase
std::string v = "1 234 567,89 RUB ";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, national
{ // zero
std::wstring v = L"0,00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0,01 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1 234 567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1 234 567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"0,00 \x440\x443\x431"".";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 \x440\x443\x431"".";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-0,01 \x440\x443\x431"".";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-0,01 \x440\x443\x431"".";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-1 234 567,89 RUB ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, international
{ // zero
std::wstring v = L"0,00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0,01 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1 234 567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1 234 567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567,89 ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"0,00 RUB ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"0,00 RUB ";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#endif
{ // negative one, showbase
std::wstring v = L"-0,01 RUB ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-0,01 RUB ";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#endif
{ // positive, showbase
std::wstring v = L"1 234 567,89 RUB ";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-1 234 567,89 RUB ";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#include "platform_support.h" // locale name macros
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet
: public Fn
: Fn(refs) {}
};
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw
: public Fw
// char, national
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "\xEF\xBF\xA5""0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "\xEF\xBF\xA5""-0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "\xEF\xBF\xA5""1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// char, international
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "CNY 0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "CNY 0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "CNY -0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "CNY -0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "CNY 1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "CNY 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "CNY -1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "\xEF\xBF\xA5""-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, national
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"\xFFE5""0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"\xFFE5""0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"\xFFE5""-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"\xFFE5""-0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"\xFFE5""1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, international
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"CNY 0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"CNY 0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"CNY -0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"CNY -0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"CNY 1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"CNY 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"CNY -1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"\xFFE5""-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
long double ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#include "platform_support.h" // locale name macros
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, cpp17_input_iterator<const char*> > Fn;
class my_facet
: public Fn
: Fn(refs) {}
};
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, cpp17_input_iterator<const wchar_t*> > Fw;
class my_facetw
: public Fw
// char, national
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "$0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "$0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-$0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-$0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "$1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// char, international
{ // zero
std::string v = "0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::string v = "-0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::string v = "1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::string v = "-1234567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::string v = "USD 0.00";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::string v = "USD 0.00";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::string v = "-USD 0.01";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::string v = "-USD 0.01";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::string v = "USD 1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::string v = "USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::string v = "-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::string v = "-$1,234,567.89";
- typedef input_iterator<const char*> I;
+ typedef cpp17_input_iterator<const char*> I;
std::string ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, national
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"$0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"$0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-$0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-$0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"$1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
// wchar_t, international
{ // zero
std::wstring v = L"0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one
std::wstring v = L"-0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive
std::wstring v = L"1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative
std::wstring v = L"-1234567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // zero, showbase
std::wstring v = L"USD 0.00";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // zero, showbase
std::wstring v = L"USD 0.00";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative one, showbase
std::wstring v = L"-USD 0.01";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative one, showbase
std::wstring v = L"-USD 0.01";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // positive, showbase
std::wstring v = L"USD 1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // positive, showbase
std::wstring v = L"USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-USD 1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
showbase(ios);
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
}
{ // negative, showbase
std::wstring v = L"-$1,234,567.89";
- typedef input_iterator<const wchar_t*> I;
+ typedef cpp17_input_iterator<const wchar_t*> I;
std::wstring ex;
std::ios_base::iostate err = std::ios_base::goodbit;
I iter = f.get(I(v.data()), I(v.data() + v.size()),
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "12";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char str[] = "*12";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+0);
assert(err == ios.failbit);
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+0);
assert(err == ios.failbit);
const char str[] = "true";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "false";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, b);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "a";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+1),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.eofbit);
const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+3),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.failbit);
const char str[] = "acc";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+3),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
const char str[] = "a";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+1),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.eofbit);
const char str[] = "ab";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+2),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+2),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.eofbit);
const char str[] = "abc";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+3),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+3),
ios, err, b);
assert(iter.base() == str+2);
assert(err == ios.goodbit);
const char str[] = "ac";
std::ios_base::iostate err = ios.goodbit;
bool b;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+2),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+2),
ios, err, b);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
#include "test_iterators.h"
#include "hexfloat.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "125e-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0x125p-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "nan";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "NAN";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
v = -1;
const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "1.79779e+309"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "-1.79779e+308"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "123_456_78_9;125";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "3;14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+10";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_iterators.h"
#include "hexfloat.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "125e-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0x125p-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "nan";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "NAN";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "3.40283e+39"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "-3.40283e+38"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+4);
assert(err == ios.goodbit);
const char str[] = "123";
oct(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
const char str[] = "123";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+3);
assert(err == ios.goodbit);
const char str[] = "0x123";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "123";
ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0x123";
ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0123";
ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "2-";
ios.setf(zf, ios.basefield);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "123"; // no separators at all
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+1_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+_1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "_+1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+1__";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+_1_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "_+1_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+__1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "_+_1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "__+1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+1_2";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+12_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+_12";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+1__2";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+12_3";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+1_23";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+1_23_4";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+123_4";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+12_34";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+12_34_5";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+123_45_6";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+1_23_45_6";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "+1_234_56_7";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "+1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "-1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "1_234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
v = -1;
const char str[] = "1234_567_89_0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
"1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
#include "test_iterators.h"
#include "hexfloat.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
assert((ios.flags() & ios.basefield) == ios.dec);
assert(ios.getloc().name() == "C");
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-123";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "123.5";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "125e-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0x125p-1";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-inf";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "-INF";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "nan";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "NAN";
hex(ios);
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "1.189731495357231765021264e+49321";
std::ios_base::iostate err = ios.goodbit;
v = 0;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char str[] = "1.189731495357231765021264e+49329";
std::ios_base::iostate err = ios.goodbit;
v = 0;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char str[] = "11.189731495357231765021264e+4932";
std::ios_base::iostate err = ios.goodbit;
v = 0;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char str[] = "91.189731495357231765021264e+4932";
std::ios_base::iostate err = ios.goodbit;
v = 0;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char str[] = "304888344611713860501504000000";
std::ios_base::iostate err = ios.goodbit;
v = 0;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err != ios.failbit);
v = -1;
const char str[] = "1.19973e+4933"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "-1.18974e+4932"; // unrepresentable
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
v = -1;
const char str[] = "2-";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "0x7FFFFFFFFFFFFFFF";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-0x8000000000000000";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
const char str[] = "0x0";
std::ios_base::iostate err = ios.goodbit;
void* p;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, p);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
const char str[] = "0x73";
std::ios_base::iostate err = ios.goodbit;
void* p;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, p);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "0xFFFFFFFF";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "0xFFFFFFFF";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "0xFFFFFFFFFFFFFFFF";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "0";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "0xFFFF";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
#pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
#endif
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
{
const char str[] = "-1";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.goodbit);
{
const char str[] = "-";
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+sizeof(str)),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+sizeof(str)),
ios, err, v);
assert(iter.base() == str+sizeof(str)-1);
assert(err == ios.failbit);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+size+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+size+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+size+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.goodbit);
const char* str = std_str.data();
size_t size = std_str.size();
std::ios_base::iostate err = ios.goodbit;
- input_iterator<const char*> iter =
- f.get(input_iterator<const char*>(str),
- input_iterator<const char*>(str+size+1),
+ cpp17_input_iterator<const char*> iter =
+ f.get(cpp17_input_iterator<const char*>(str),
+ cpp17_input_iterator<const char*>(str+size+1),
ios, err, v);
assert(iter.base() == str+size);
assert(err == ios.failbit);
#include "platform_support.h" // locale name macros
-typedef std::time_get_byname<char, input_iterator<const char*> > F;
+typedef std::time_get_byname<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
#include "platform_support.h" // locale name macros
-typedef std::time_get_byname<wchar_t, input_iterator<const wchar_t*> > F;
+typedef std::time_get_byname<wchar_t, cpp17_input_iterator<const wchar_t*> > F;
class my_facet
: public F
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get_byname<char, I> F;
#include "platform_support.h" // locale name macros
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get_byname<wchar_t, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef std::time_get<char, input_iterator<const char*> > F;
+typedef std::time_get<char, cpp17_input_iterator<const char*> > F;
class my_facet
: public F
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const wchar_t*> I;
+typedef cpp17_input_iterator<const wchar_t*> I;
typedef std::time_get<wchar_t, I> F;
#include "test_macros.h"
#include "test_iterators.h"
-typedef input_iterator<const char*> I;
+typedef cpp17_input_iterator<const char*> I;
typedef std::time_get<char, I> F;
TEST_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
test()
{
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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_CONSTEXPR_CXX20 bool
test()
{
- 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<cpp17_input_iterator<const int*>, cpp17_input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*>, const int*>();
- test<forward_iterator<const int*>, input_iterator<const int*> >();
+ test<forward_iterator<const int*>, cpp17_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*>, cpp17_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*>, cpp17_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*, cpp17_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_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
TEST_CONSTEXPR_CXX20 bool
test()
{
- test<input_iterator<const int*>, output_iterator<int*> >();
- test<input_iterator<const int*>, forward_iterator<int*> >();
- test<input_iterator<const int*>, bidirectional_iterator<int*> >();
- test<input_iterator<const int*>, random_access_iterator<int*> >();
- test<input_iterator<const int*>, int*>();
+ test<cpp17_input_iterator<const int*>, output_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
+ test<cpp17_input_iterator<const int*>, int*>();
test<forward_iterator<const int*>, output_iterator<int*> >();
test<forward_iterator<const int*>, forward_iterator<int*> >();
test_return_type<float>();
test_return_type<double>();
- test<input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
test_return_type<double, char>();
test_return_type<char, double>();
- test<input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
test_return_type<double, char>();
test_return_type<char, double>();
- test<input_iterator<const int*> >();
+ test<cpp17_input_iterator<const int*> >();
test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
basic_tests();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
test_return_type<char, double>();
// All the iterator categories
- test<input_iterator <const int*> >();
+ test<cpp17_input_iterator <const int*> >();
test<forward_iterator <const int*> >();
test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >();
test_return_type<char, double>();
// All the iterator categories
- test<input_iterator <const int*>, input_iterator <const unsigned int*> >();
- test<input_iterator <const int*>, forward_iterator <const unsigned int*> >();
- test<input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
- test<input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, forward_iterator <const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
- test<forward_iterator <const int*>, input_iterator <const unsigned int*> >();
+ test<forward_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >();
- test<bidirectional_iterator<const int*>, input_iterator <const unsigned int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
- test<random_access_iterator<const int*>, input_iterator <const unsigned int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
test_return_type<char, double>();
// All the iterator categories
- test<input_iterator <const int*>, input_iterator <const unsigned int*> >();
- test<input_iterator <const int*>, forward_iterator <const unsigned int*> >();
- test<input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
- test<input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, forward_iterator <const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
+ test<cpp17_input_iterator <const int*>, random_access_iterator<const unsigned int*> >();
- test<forward_iterator <const int*>, input_iterator <const unsigned int*> >();
+ test<forward_iterator <const int*>, cpp17_input_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, forward_iterator <const unsigned int*> >();
test<forward_iterator <const int*>, bidirectional_iterator<const unsigned int*> >();
test<forward_iterator <const int*>, random_access_iterator<const unsigned int*> >();
- test<bidirectional_iterator<const int*>, input_iterator <const unsigned int*> >();
+ test<bidirectional_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
- test<random_access_iterator<const int*>, input_iterator <const unsigned int*> >();
+ test<random_access_iterator<const int*>, cpp17_input_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, forward_iterator <const unsigned int*> >();
test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
#include <concepts>
+#include "test_iterators.h"
#include "test_range.h"
namespace stdr = std::ranges;
-static_assert(std::same_as<stdr::range_difference_t<test_range<> >, std::iter_difference_t<int*> >);
-static_assert(std::same_as<stdr::range_value_t<test_range<> >, std::iter_value_t<int*> >);
-static_assert(std::same_as<stdr::range_reference_t<test_range<> >, std::iter_reference_t<int*> >);
-static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<> >, std::iter_rvalue_reference_t<int*> >);
+static_assert(std::same_as<stdr::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
+static_assert(std::same_as<stdr::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
+static_assert(std::same_as<stdr::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
+static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);
namespace stdr = std::ranges;
-static_assert(std::same_as<stdr::iterator_t<test_range<input_iterator> >, input_iterator<int*> >);
-static_assert(std::same_as<stdr::iterator_t<test_range<input_iterator> const>, input_iterator<int const*> >);
+static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<stdr::iterator_t<test_non_const_range<input_iterator> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> >, input_iterator<int*> >);
-static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> const>, input_iterator<int const*> >);
+static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<input_iterator> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
namespace stdr = std::ranges;
-static_assert(stdr::range<test_range<> >);
+static_assert(stdr::range<test_range<cpp20_input_iterator> >);
struct incompatible_iterators {
int* begin();
namespace stdr = std::ranges;
-static_assert(std::same_as<stdr::sentinel_t<test_range<> >, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_range<> const>, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<> >, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_common_range<> >, input_iterator<int*> >);
-static_assert(std::same_as<stdr::sentinel_t<test_common_range<> const>, input_iterator<int const*> >);
-static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
+static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
namespace stdr = std::ranges;
-static_assert(!stdr::common_range<test_range<input_iterator> >);
-static_assert(!stdr::common_range<test_range<input_iterator> const>);
+static_assert(!stdr::common_range<test_range<cpp17_input_iterator> >);
+static_assert(!stdr::common_range<test_range<cpp17_input_iterator> const>);
-static_assert(!stdr::common_range<test_non_const_range<input_iterator> >);
-static_assert(!stdr::common_range<test_non_const_range<input_iterator> const>);
+static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> >);
+static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> const>);
-static_assert(stdr::common_range<test_common_range<input_iterator> >);
-static_assert(stdr::common_range<test_common_range<input_iterator> const>);
+static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> >);
+static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> const>);
-static_assert(stdr::common_range<test_non_const_common_range<input_iterator> >);
-static_assert(!stdr::common_range<test_non_const_common_range<input_iterator> const>);
+static_assert(stdr::common_range<test_non_const_common_range<cpp17_input_iterator> >);
+static_assert(!stdr::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
struct subtly_not_common {
int* begin() const;
#include <ranges>
+#include "test_iterators.h"
#include "test_range.h"
namespace stdr = std::ranges;
-static_assert(stdr::input_range<test_range<input_iterator> >);
-static_assert(stdr::input_range<test_range<input_iterator> const>);
+static_assert(stdr::input_range<test_range<cpp17_input_iterator> >);
+static_assert(stdr::input_range<test_range<cpp17_input_iterator> const>);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> >);
static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>);
-static_assert(stdr::input_range<test_non_const_range<input_iterator> >);
+static_assert(stdr::input_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >);
-static_assert(!stdr::input_range<test_non_const_range<input_iterator> const>);
+static_assert(!stdr::input_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>);
-static_assert(stdr::input_range<test_common_range<input_iterator> >);
+static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >);
-static_assert(stdr::input_range<test_common_range<input_iterator> const>);
+static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>);
-static_assert(stdr::input_range<test_non_const_common_range<input_iterator> >);
+static_assert(stdr::input_range<test_non_const_common_range<cpp17_input_iterator> >);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >);
-static_assert(!stdr::input_range<test_non_const_common_range<input_iterator> const>);
+static_assert(!stdr::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>);
int main(int, char**)
{
- typedef input_iterator<std::string::const_iterator> I;
+ typedef cpp17_input_iterator<std::string::const_iterator> I;
typedef forward_iterator<std::string::const_iterator> F;
std::string s4("(a([bc]))");
std::regex r2;
#include <iterator>
template <class It>
-class input_iterator
+class cpp17_input_iterator
{
It it_;
public:
typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference;
- input_iterator() : it_() {}
- explicit input_iterator(It it) : it_(it) {}
+ cpp17_input_iterator() : it_() {}
+ explicit cpp17_input_iterator(It it) : it_(it) {}
reference operator*() const {return *it_;}
pointer operator->() const {return it_;}
- input_iterator& operator++() {++it_; return *this;}
- input_iterator operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;}
+ cpp17_input_iterator& operator++() {++it_; return *this;}
+ cpp17_input_iterator operator++(int) {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
- friend bool operator==(const input_iterator& x, const input_iterator& y)
+ friend bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return x.it_ == y.it_;}
- friend bool operator!=(const input_iterator& x, const input_iterator& y)
+ friend bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return !(x == y);}
};
assert(w == L"abcdef");
}
{ // (8) w/o allocator
- using It = input_iterator<const char*>;
+ using It = cpp17_input_iterator<const char*>;
const char* input = "abcdef";
std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
ASSERT_SAME_TYPE(decltype(s), std::string);
}
{ // (8) w/ allocator
using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
- using It = input_iterator<const wchar_t*>;
+ using It = cpp17_input_iterator<const wchar_t*>;
const wchar_t* input = L"abcdef";
std::basic_string s(It(input), It(input + 3), test_allocator<wchar_t>{});
ASSERT_SAME_TYPE(decltype(s), ExpectW);
#include "test_macros.h"
#include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../cpp17_input_iterator.h"
#include "min_allocator.h"
template <class It>
test(s, s+50);
test(s, s+50, A(2));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s), A(2));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A(2));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A(2));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A(2));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+10));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A(2));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A(2));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+50));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A(2));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A(2));
}
#if TEST_STD_VER >= 11
{
test(s, s+50);
test(s, s+50, A());
- test(input_iterator<const char*>(s), input_iterator<const char*>(s));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s), A());
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), A());
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A());
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), A());
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+10));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A());
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), A());
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+50));
- test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A());
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50));
+ test(cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+50), A());
}
#endif
{
#include "test_macros.h"
#include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../cpp17_input_iterator.h"
#include "min_allocator.h"
int main(int, char**)
#include "test_macros.h"
#include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../cpp17_input_iterator.h"
#include "min_allocator.h"
int main(int, char**)
#include "test_macros.h"
#include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../cpp17_input_iterator.h"
#include "min_allocator.h"
int main(int, char**)
test(S("12345678901234567890"), s, s+52,
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345A"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345ABCDEFGHIJ"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("1234567890"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("1234567890A"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("1234567890ABCDEFGHIJ"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345678901234567890"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345678901234567890""A"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345678901234567890""ABCDEFGHIJ"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#if TEST_STD_VER >= 11
test(S("12345678901234567890"), s, s+52,
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345A"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345ABCDEFGHIJ"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("1234567890"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("1234567890A"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("1234567890ABCDEFGHIJ"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S("12345678901234567890"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("12345678901234567890""A"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("12345678901234567890""ABCDEFGHIJ"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#endif
{ // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
- typedef input_iterator<TIter> IIter;
+ typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test(S("12345678901234567890"), s, s+52,
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#if TEST_STD_VER >= 11
test(S("12345678901234567890"), s, s+52,
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("1234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s),
S());
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
S("A"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
S("ABCDEFGHIJ"));
- test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#endif
{ // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
- typedef input_iterator<TIter> IIter;
+ typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
test(S("12345678901234567890"), 20, s, s+52,
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
- test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345"));
- test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345"));
- test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
- test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
- test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890"));
- test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890"));
- test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
- test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
-
- test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890"));
- test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890"));
- test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
- test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+ test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
+ test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
+ test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
+ test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+ test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
+ test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
+ test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
+ test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
+
+ test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
+ test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
+ test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
+ test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#if TEST_STD_VER >= 11
test(S("12345678901234567890"), 20, s, s+52,
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S());
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
- test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
- test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345"));
- test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345"));
- test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
- test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
- test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890"));
- test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890"));
- test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
- test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
-
- test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890"));
- test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890"));
- test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
- test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S());
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("A"));
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
+ test(S(), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+ test(S("12345"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345"));
+ test(S("12345"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A2345"));
+ test(S("12345"), 4, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
+ test(S("12345"), 5, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+ test(S("1234567890"), 0, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("1234567890"));
+ test(S("1234567890"), 1, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("1A234567890"));
+ test(S("1234567890"), 10, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
+ test(S("1234567890"), 8, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
+
+ test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
+ test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
+ test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
+ test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
}
#endif
{ // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
- typedef input_iterator<TIter> IIter;
+ typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
}
{ // test with a move iterator that returns char&&
- typedef input_iterator<const char*> It;
+ typedef cpp17_input_iterator<const char*> It;
typedef std::move_iterator<It> MoveIt;
const char p[] = "ABCD";
std::string s;
{ // test iterator operations that throw
typedef std::string S;
typedef ThrowingIterator<char> TIter;
- typedef input_iterator<TIter> IIter;
+ typedef cpp17_input_iterator<TIter> IIter;
const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
void test_counted()
{
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
using FIt = forward_iterator<Counted*>;
const int N = 5;
int values[N] = {1, 2, 3, 4, 5};
void test_counted()
{
- using It = input_iterator<int*>;
+ using It = cpp17_input_iterator<int*>;
using FIt = forward_iterator<Counted*>;
const int N = 5;
int values[N] = {1, 2, 3, 4, 5};
void operator,(T const &) DELETE_FUNCTION;
};
+// This is the Cpp17InputIterator requirement as described in Table 87 ([input.iterators]),
+// formerly known as InputIterator prior to C++20.
template <class It,
class ItTraits = It>
-class input_iterator
+class cpp17_input_iterator
{
typedef std::iterator_traits<ItTraits> Traits;
It it_;
- template <class U, class T> friend class input_iterator;
+ template <class U, class T> friend class cpp17_input_iterator;
public:
typedef std::input_iterator_tag iterator_category;
typedef typename Traits::value_type value_type;
TEST_CONSTEXPR_CXX14 It base() const {return it_;}
- TEST_CONSTEXPR_CXX14 input_iterator() : it_() {}
- explicit TEST_CONSTEXPR_CXX14 input_iterator(It it) : it_(it) {}
+ TEST_CONSTEXPR_CXX14 cpp17_input_iterator() : it_() {}
+ explicit TEST_CONSTEXPR_CXX14 cpp17_input_iterator(It it) : it_(it) {}
template <class U, class T>
- TEST_CONSTEXPR_CXX14 input_iterator(const input_iterator<U, T>& u) :it_(u.it_) {}
+ TEST_CONSTEXPR_CXX14 cpp17_input_iterator(const cpp17_input_iterator<U, T>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
- TEST_CONSTEXPR_CXX14 input_iterator& operator++() {++it_; return *this;}
- TEST_CONSTEXPR_CXX14 input_iterator operator++(int)
- {input_iterator tmp(*this); ++(*this); return tmp;}
+ TEST_CONSTEXPR_CXX14 cpp17_input_iterator& operator++() {++it_; return *this;}
+ TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int)
+ {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
- friend TEST_CONSTEXPR_CXX14 bool operator==(const input_iterator& x, const input_iterator& y)
+ friend TEST_CONSTEXPR_CXX14 bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return x.it_ == y.it_;}
- friend TEST_CONSTEXPR_CXX14 bool operator!=(const input_iterator& x, const input_iterator& y)
+ friend TEST_CONSTEXPR_CXX14 bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
{return !(x == y);}
template <class T>
template <class T, class TV, class U, class UV>
inline
bool
-operator==(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y)
+operator==(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
{
return x.base() == y.base();
}
template <class T, class TV, class U, class UV>
inline
bool
-operator!=(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y)
+operator!=(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
{
return !(x == y);
}
inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); }
template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(input_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(cpp17_input_iterator<Iter> i) { return i.base(); }
template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); }
};
// clang-format off
-template <template <class...> class I = input_iterator>
+template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> >
struct test_range {
I<int*> begin();
sentinel end() const;
};
-template <template <class...> class I = input_iterator>
+template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> >
struct test_non_const_range {
I<int*> begin();
sentinel end();
};
-template <template <class...> class I = input_iterator>
+template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> >
struct test_common_range {
I<int*> begin();
I<int const*> end() const;
};
-template <template <class...> class I = input_iterator>
+template <template <class...> class I>
requires std::input_or_output_iterator<I<int*> >
struct test_non_const_common_range {
I<int*> begin();