[libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`

[cjdb]

Summary

C++20 revised the definition of what it means to be an iterator. While
all _Cpp17InputIterators_ satisfy std::input_iterator, the reverse
isn't true. D100271 introduces a new test adaptor to accommodate this
new definition (cpp20_input_iterator).

In order to help readers immediately distinguish which input iterator
adaptor is _Cpp17InputIterator_, the current input_iterator adaptor
has been prefixed with cpp17_.

[• Quuxplusone]

It seems like literally all this does is make the test iterators' names longer and more tedious, so I personally don't think we should accept this patch.

[cjdb]

benchmark file was not updated (tooling only considered files in libcxx/test/)

[Mordante]

I had a short look at the patch. I also wonder whether this is the direction we want to go.
For reviewing, I assume this is all basically a search and replace? Or are there more changes?

libcxx/test/support/test_iterators.h

1

The new C++20 style iterators will they also be put in this file or will they get their own header. If the latter then maybe rename this file to test_legacy_iterator.h.

[cjdb]

In D101242#2715229, @Mordante wrote:

I had a short look at the patch. I also wonder whether this is the direction we want to go.

The intention of this patch is to optimise for the reader, not the writer. I don't want any contributors or reviewers to question whether input_iterator means legacy input iterator or C++20 input iterator.

For reviewing, I assume this is all basically a search and replace? Or are there more changes?

Should be a 100% search and replace with one file renamed too (input_iterator.h -> legacy_input_iterator.h).

libcxx/test/support/test_iterators.h

1

My intention was to add them here and guard them with a ranges support macro. C++20 ranges may want to test both in certain circumstances.

[ldionne]

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

Requesting changes for discussion.

[• Quuxplusone]

The intention of this patch is to optimise for the reader, not the writer.

As a reader myself, I explicitly state that this patch does not optimize for my preferences when reading code. It makes the code actively harder to read.

[cjdb]

In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

[ldionne]

In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

[cjdb]

In D101242#2717230, @ldionne wrote:

In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

Contrast:

• iterator.concept.forward with forward.iterators (postfix operator++ requirement differs, reference DNE for forward_iterator and iter_reference_t may have different requirements)
• iterator.concept.bidir with bidirectional.iterators (postfix operator-- requirement differs)
• iterator.concept.random.access with random.access.iterators

tl;dr yes. At minimum, the iterator tags are now mandatory.

[Mordante]

In D101242#2717221, @cjdb wrote:

In D101242#2717210, @ldionne wrote:

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I'm not too fond of the name Legacy. Unless I'm mistaken the standard uses Cpp17 for these iterators. So that would be my preference.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

I have a strong opinion about the renaming of the header. Just wanted to make sure there wouldn't be a second update in the near future.

[• Quuxplusone]

libcxx/test/support/test_iterators.h

66

@cjdb wrote:

tl;dr yes. At minimum, the iterator tags are now mandatory.

The existing iterators already have tags, though. So that's not a concern for us.

I suggested to Louis in chat but will put here for the record: If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself), then I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator, like this:

#if TEST_STD_VER >= 20
template<class It>
class incomparable_input_iterator {
    // This is an input iterator according to C++>=20, but not according to C++<=17.
    // It is comparable with its sentinel type, but not with its own type.
    [...mostly the same stuff as the regular input iterator test type...]
public:
    struct sentinel {
        constexpr explicit sentinel(It it) : it_(it) {}
    };
    friend constexpr bool operator==(const incomparable_input_iterator& x, const sentinel& y)
        {return x.it_ == y.it_;}
};
#endif

This probably belongs right above contiguous_iterator, circa line 315, because we intend it to be new in C++20.

[cjdb]

libcxx/test/support/test_iterators.h

66

If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself)

This isn't the only difference between Cpp17InputIterator and std::input_iterator.

I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator

That leaves ambiguity as to whether or not input_iterator refers to a Cpp17InputIterator or is a strict std::input_iterator. It needs to be renamed to clear up that ambiguity.

[• Quuxplusone]

libcxx/test/support/test_iterators.h

66

This isn't the only difference

Obligatory "What are the differences you care about, then?"
No two things in the world are ever exactly the same. That doesn't mean we make libc++ PRs about it. :)

[cjdb]

libcxx/test/support/test_iterators.h

66

The most salient difference is that C++20 input iterators need not be copyable. I expected that this would be fresh in your mind, since you've recently reviewed D100271, which is why I didn't mention it.

[cjdb]

• reverts legacy_forward_iterator (and stronger)
• replaces legacy prefix with cpp17
• revises commit message to reflect drastic changes

[• Quuxplusone]

libcxx/test/support/test_iterators.h

66

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy. Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

(Fortunately, std::forward_iterator and higher all require std::regular, which means "copyable and comparable"; so the above combinatorial explosion applies only to input iterators and output iterators.)

[cjdb]

libcxx/test/support/test_iterators.h

66

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

That + prefixing current input_iterator with cpp17_ (or copyable_, which is more descriptive, but longer).

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy.

The patch has no need for a sentinel, so it's not added. I think it'd be a good idea for us to think about what the new sentinel type should do, and add it either with the first algorithm or as a follow-up patch to D100271 (it certainly shouldn't be blocking).

Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

Yeah, that's a bad idea. My intention is for the new, move-only input iterator is for it to be a completely minimal interface (i.e. move-only, not a self-sentinel).

[ldionne]

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

LGTM but please add a one-line comment saying This is the InputIterator concept as described prior to C++20 or something along those lines.

[Mordante]

In D101242#2720585, @ldionne wrote:

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

Nice!
LGTM.

[ldionne]

Can we apply the feedback and land this? Sorry to be pushy, but this is a large change (in terms of touched lines) and I'd like to get it in ASAP.

[cjdb]

adds a comment explaining what cpp17_input_iterator represents

[cjdb]

rebases to fix CI

[cjdb]

tries to get CI working once more

[• Quuxplusone]

libcxx/benchmarks/filesystem.bench.cpp

69

This legacy_ should also be cpp17_, right? (I think a git grep would help here.)

[cjdb]

fixes benchmark

libcxx/benchmarks/filesystem.bench.cpp

69

Thanks! TIL about git grep.

libcxx/benchmarks/filesystem.bench.cpp

void BM_PathConstructIter(benchmark::State &st, GenInputs gen) {
   while (st.KeepRunning()) {
     const path P(Start, End);
     benchmark::DoNotOptimize(P.native().data());
   }
   st.SetComplexityN(st.range(0));
 }
 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) {
   BM_PathConstructIter<forward_iterator>(st, gen);
 }
 BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string,
   getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
 BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string,
   getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
 
 
 template <class GenInputs>

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp

 int main(int, char**)
 {
     {
         std::list<int> v(100);
         std::list<int> v2(100);
         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);
     }
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp

#if TEST_STD_VER >= 11
         C c(std::begin(t), std::end(t));
         c.reserve(2*c.size());
         volatile T foo = c[c.size()];    // bad, but not caught by ASAN
         ((void)foo);
     }
 #endif
 
     {
-        typedef input_iterator<int*> MyInputIter;
+        typedef cpp17_input_iterator<int*> MyInputIter;
         // Sould not trigger ASan.
         std::vector<int> v;
         v.reserve(1);
         int i[] = {42};
         v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1));
         assert(v[0] == 42);
         assert(is_contiguous_container_asan_correct(v));
     }

libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp

struct MakeTestType {
   using string_type = std::basic_string<CharT>;
   using string_type2 = std::basic_string<CharT, std::char_traits<CharT>, min_allocator<CharT>>;
   using string_view_type = std::basic_string_view<CharT>;
   using string_view_type2 = std::basic_string_view<CharT, constexpr_char_traits<CharT>>;
   using cstr_type = CharT* const;
   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() {
     static_assert(__is_pathable<TestT>::value, "");
     static_assert(CheckPassSource<TestT>::value, "cannot pass as Source const&");
     ASSERT_SAME_TYPE(CharT, typename __is_pathable<TestT>::__char_type);
   }
 

libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp

 #if TEST_STD_VER >= 20
     static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<my_contiguous_iterator> >::value), "");
     static_assert(( std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::__wrap_iter<my_contiguous_iterator> > >::value), "");
     static_assert((!std::__is_cpp17_contiguous_iterator<std::__wrap_iter<std::reverse_iterator<my_contiguous_iterator> > >::value), "");
 #endif
 
 //  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), "");
 #if TEST_STD_VER >= 20
     static_assert(( std::__is_cpp17_contiguous_iterator<contiguous_iterator   <char *> >::value), "");
 #endif
     static_assert((!std::__is_cpp17_contiguous_iterator<ThrowingIterator      <char *> >::value), "");
     static_assert((!std::__is_cpp17_contiguous_iterator<NonThrowingIterator   <char *> >::value), "");

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

test_copy()
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
 }
 
 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<forward_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy<forward_iterator<const int*>, random_access_iterator<int*> >();
     test_copy<forward_iterator<const int*>, int*>();
 
     test_copy<bidirectional_iterator<const int*>, output_iterator<int*> >();
test()
 
     test_copy<const int*, output_iterator<int*> >();
     test_copy<const int*, forward_iterator<int*> >();
     test_copy<const int*, bidirectional_iterator<int*> >();
     test_copy<const int*, random_access_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_copy<const int*, contiguous_iterator<int*>>();
 
     test_copy<contiguous_iterator<const int*>, output_iterator<int*>>();
     test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>();
     test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

test_copy_if()
     assert(base(r) == ib+N/3+1);
     for (unsigned i = 0; i < N/3+1; ++i)
         assert(ib[i] % 3 == 0);
 }
 
 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_copy_if<const int*, int*>();
 
   return true;
 }
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

test_copy_n()
     assert(base(r) == ib+N/2);
     for (unsigned i = 0; i < N/2; ++i)
         assert(ia[i] == ib[i]);
 }
 
 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*> >();
     test_copy_n<const int*, int*>();
 
   return true;
 }
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

test1()
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
         assert(*ib[i] == static_cast<int>(i));
 }
 #endif
 
 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<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*> >();
int main(int, char**)
 
     test<const int*, output_iterator<int*> >();
     test<const int*, forward_iterator<int*> >();
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_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>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
#if TEST_STD_VER >= 11
     test1<std::unique_ptr<int>*, output_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, 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<const int*, contiguous_iterator<int*>>();
     test<contiguous_iterator<const int*>, output_iterator<int*>>();
     test<contiguous_iterator<const int*>, forward_iterator<int*>>();
     test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
     test<contiguous_iterator<const int*>, random_access_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<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
     test1<contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>();
     test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>();
     test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
     test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_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*> >());
     static_assert(test<const int*, contiguous_iterator<int*> >());
     static_assert(test<const int*, int*>());
 #endif // TEST_STD_VER > 17
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
 
 int main(int, char**) {
   {
     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)));
   }
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

 
 int main(int, char**)
 {
     {
         const int ia[] = {1, 2, 3, 4, 6, 8, 5, 7};
         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);
         assert(r1[1] == 3);
         assert(r1[2] == 5);
         assert(r1[3] == 7);
         assert(p.second == r2 + 4);
         assert(r2[0] == 2);

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp

template <class PopulationIterator, class SampleIterator> void test() {
   std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
                             SampleIterator(oa), os, g);
 }
 
 int main(int, char**) {
   // 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;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

void test_small_population() {
   if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) {
     assert(std::equal(oa, end.base(), oa1));
   } else {
     assert(std::is_permutation(oa, end.base(), oa1));
   }
 }
 
 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>();
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp

for (int i = 0; i < kIterations; ++i) {
     std::sample(first, last, out, kSampleSize, g);
     unstable |= !std::is_sorted(oa, oa + kSampleSize);
   }
   assert(expect_stable == !unstable);
 }
 
 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;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp

test()
     assert(ib[2] == 3);
     assert(ib[3] == 4);
     assert(ib[4] == 3);
     assert(ib[5] == 4);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp

test()
     assert(ib[2] == 3);
     assert(ib[3] == 4);
     assert(ib[4] == 3);
     assert(ib[5] == 4);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp

test()
     assert(ib[1] == 1);
     assert(ib[2] == 5);
     assert(ib[3] == 3);
     assert(ib[4] == 4);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp

test()
     assert(ib[1] == 1);
     assert(ib[2] == 5);
     assert(ib[3] == 3);
     assert(ib[4] == 4);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp

test()
     assert(ib[1] == 1);
     assert(ib[2] == 1);
     assert(ib[3] == 1);
     assert(ib[4] == 1);
 }
 
 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*> >();
     test<const int*, const int*, int*>();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp

test()
     assert(ib[1] == 2);
     assert(ib[2] == 3);
     assert(ib[3] == 4);
     assert(ib[4] == 5);
 }
 
 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*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

test()
     assert(base(r) == ji + 3);
     assert(ji[0] == 0);
     assert(ji[1] == 1);
     assert(ji[2] == 2);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp

test()
     assert(ji[0] == 0);
     assert(ji[1] == 1);
     assert(ji[2] == 2);
     assert(count_equal::count == si-1);
 }
 
 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<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*> >();

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp

TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
 int main(int, char**)
 {
     {
         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
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp

TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
 int main(int, char**)
 {
     {
         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
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp

return    (std::count(std::begin(ia), std::end(ia), 2) == 3)
            ;
     }
 #endif
 
 int main(int, char**)
 {
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp

return    (std::count_if(std::begin(ia), std::end(ia), eq(2)) == 3)
            ;
     }
 #endif
 
 int main(int, char**)
 {
     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
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

 #include "test_macros.h"
 #include "test_iterators.h"
 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool test_constexpr() {
     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))
         && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic))
         &&  std::equal(std::begin(ib), std::end(ib), std::begin(ic))
         && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic))
 
         &&  std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)))
         && !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)))
         ;
     }
 #endif
 
 
 int main(int, char**)
 {
     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),
                        random_access_iterator<const int*>(ia+s-1)));
 
 #endif
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
 
 TEST_CONSTEXPR bool test_constexpr() {
     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)
         && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq)
         &&  std::equal(std::begin(ib), std::end(ib), std::begin(ic)              , eq)
         && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), eq)
 
         &&  std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic))                  , eq)
bool counting_equals ( const T &a, const T &b ) {
     return a == b;
 }
 
 int main(int, char**)
 {
     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),
                       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;
     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-1),
                       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),
                        random_access_iterator<const int*>(ib),
                        random_access_iterator<const int*>(ib+s),
                        std::equal_to<int>()));
 #endif
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp

 #endif
 
 int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

 #endif
 
 int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

return    (std::find(std::begin(ia), std::end(ia), 5) == ia+2)
            ;
     }
 #endif
 
 int main(int, char**)
 {
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp

return    (std::find_if(std::begin(ia), std::end(ia), c) == ia+4)
            ;
     }
 #endif
 
 int main(int, char**)
 {
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp

return    (std::find_if_not(std::begin(ia), std::end(ia), c) == ia+4)
            ;
     }
 #endif
 
 int main(int, char**)
 {
     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());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp

 {
     for_each_test(int c) : count(c) {}
     int count;
     void operator()(int& i) {++i; ++count;}
 };
 
 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]);
 
     {
     auto f = for_each_test(0);
     Iter it = std::for_each_n(Iter(ia), 0, std::ref(f));
     assert(it == Iter(ia));
     assert(f.count == 0);

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

struct for_each_test
     int count;
     void operator()(int& i) {++i; ++count;}
 };
 
 int main(int, char**)
 {
     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)
         assert(ia[i] == static_cast<int>(i+1));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp

TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
 int main(int, char**)
 {
     {
         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
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp

 #include "test_macros.h"
 #include "test_iterators.h"
 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool test_constexpr() {
     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));
     if (p1.first != ia+2 || p1.second != ic+2)
         return false;
 
     auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic));
     if (p2.first != ia+2 || p2.second != ic+2)

 
 int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     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))
             == (std::pair<II, II>(II(ia+3), II(ib+3))));
 
     assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib))
             == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
 

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
 
 TEST_CONSTEXPR bool test_constexpr() {
     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);
     if (p1.first != ia+2 || p1.second != ic+2)
         return false;
 
     auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq);
     if (p2.first != ia+2 || p2.second != ic+2)

 
 int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     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;
 
     assert(std::mismatch(II(ia), II(ia + sa), II(ib), EQ())
             == (std::pair<II, II>(II(ia+3), II(ib+3))));
     assert(std::mismatch(RAI(ia), RAI(ia + sa), RAI(ib), EQ())
             == (std::pair<RAI, RAI>(RAI(ia+3), RAI(ib+3))));
 

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

test()
     assert(!std::lexicographical_compare(Iter1(ia),   Iter1(ia+sa), Iter2(ib),   Iter2(ib+3)));
     assert( std::lexicographical_compare(Iter1(ib),   Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa)));
     assert( std::lexicographical_compare(Iter1(ia),   Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3)));
     assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa)));
 }
 
 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*> >();
     test<const int*, const int*>();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp

test()
     assert(!std::lexicographical_compare(Iter1(ia),   Iter1(ia+sa), Iter2(ib),   Iter2(ib+3),  c));
     assert( std::lexicographical_compare(Iter1(ib),   Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa), c));
     assert(!std::lexicographical_compare(Iter1(ia),   Iter1(ia+sa), Iter2(ib+1), Iter2(ib+3),  c));
     assert( std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa), c));
 }
 
 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*> >();
     test<const int*, const int*>();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp

 #include <algorithm>
 #include <cassert>
 
 #include "test_iterators.h"
 
 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));
   }
   {
     // expected-error@algorithm:* {{"std::max_element requires a ForwardIterator"}}
     std::max_element(Iter(b), Iter(e));
   }
   {
     // expected-error@algorithm:* {{"std::minmax_element requires a ForwardIterator"}}
     std::minmax_element(Iter(b), Iter(e));
   }
 
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp

void test()
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2)));
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3)));
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4)));
 }
 
 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<const int*, const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     do_tests();
 #if TEST_STD_VER > 17
     static_assert(do_tests());
 #endif
     return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp

void test()
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+2), std::greater<int>()));
     assert(std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+3), std::greater<int>()));
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::greater<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*> >();
     test<const int*, const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     do_tests();
 #if TEST_STD_VER > 17
     static_assert(do_tests());
 #endif
     return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

TEST_CONSTEXPR_CXX20 void test3()
     test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
     test4<T, Iter1, Iter2, random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, 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*> >();
     test3<T, Iter1, 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*> >();
     test2<T, const T*>();
 }
 
 TEST_CONSTEXPR_CXX20 bool test()
 {

libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp

int main(int, char**)
             P(2, 1),
             P(2, 1.5),
             P(2, 2),
             P(3, 1),
             P(3, 1.5),
             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);
         assert(next(m.begin())->first == 2);
         assert(next(m.begin())->second == 1);
         assert(next(m.begin(), 2)->first == 3);
         assert(next(m.begin(), 2)->second == 1);
     }
#if TEST_STD_VER >= 11
             P(2, 1),
             P(2, 1.5),
             P(2, 2),
             P(3, 1),
             P(3, 1.5),
             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);
         assert(next(m.begin())->first == 2);
         assert(next(m.begin())->second == 1);
         assert(next(m.begin(), 2)->first == 3);
         assert(next(m.begin(), 2)->second == 1);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp

int main(int, char**)
             P(2, 1),
             P(2, 1.5),
             P(2, 2),
             P(3, 1),
             P(3, 1.5),
             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);
         assert(next(m.begin())->first == 1);
         assert(next(m.begin())->second == 1.5);
         assert(next(m.begin(), 2)->first == 1);
         assert(next(m.begin(), 2)->second == 2);
         assert(next(m.begin(), 3)->first == 2);
#if TEST_STD_VER >= 11
             P(2, 1),
             P(2, 1.5),
             P(2, 2),
             P(3, 1),
             P(3, 1.5),
             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);
         assert(next(m.begin())->first == 1);
         assert(next(m.begin())->second == 1.5);
         assert(next(m.begin(), 2)->first == 1);
         assert(next(m.begin(), 2)->second == 2);
         assert(next(m.begin(), 3)->first == 2);

libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp

int main(int, char**)
             2,
             2,
             2,
             3,
             3,
             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);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
#if TEST_STD_VER >= 11
             2,
             2,
             2,
             3,
             3,
             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);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp

V ar[] =
         1,
         2,
         2,
         2,
         3,
         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);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
V ar[] =
         1,
         2,
         2,
         2,
         3,
         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);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp

V ar[] =
         2,
         2,
         3,
         3,
         3
     };
     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));
     assert(m.size() == 9);
     assert(distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp

V ar[] =
         2,
         2,
         2,
         3,
         3,
         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);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
 
   return 0;
 }

libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp

int main(int, char**)
             2,
             2,
             2,
             3,
             3,
             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);
         assert(*next(m.begin(), 2) == 3);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
             2,
             2,
             3,
             3,
             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);
         assert(*next(m.begin(), 2) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp

V ar[] =
         1,
         2,
         2,
         2,
         3,
         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);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
 #if TEST_STD_VER >= 11
     {
     typedef int V;
     V ar[] =
     {
         1,
         1,
         1,
         2,
         2,
         2,
         3,
         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);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp

V ar[] =
         2,
         2,
         3,
         3,
         3
     };
     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));
     assert(m.size() == 3);
     assert(distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);

libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp

V ar[] =
         2,
         2,
         2,
         3,
         3,
         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);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp

testN(int start, int N, int M)
     test(c1, c2);
 }
 
 template <class C>
 void
 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);
 }
 
 template <class C>
 void
 testNI(int start, int N, int M)
using It = random_access_iterator<int*>;
       v.assign(It(arr2), It(std::end(arr2)));
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     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)));
       assert(v[0].copied == 0);
       assert(v[0].value == 42);
     }
     {
       std::deque<T> v;

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp

test(InputIterator f, InputIterator l)
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     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));
     test<limited_allocator<int, 4096> >(ab, an);
 #if TEST_STD_VER >= 11
     test<min_allocator<int> >(ab, an);
 #endif
 }
using It = random_access_iterator<int*>;
       std::deque<T> v(It(arr2), It(std::end(arr2)));
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     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);
       assert(v[0].value == 42);
     }
     {
       std::deque<T> v(It(arr2), It(std::end(arr2)));
       //assert(v[0].copied == 0);

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp

test(InputIterator f, InputIterator l, const Allocator& a)
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     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>());
 #endif
 }
 
 
 void test_emplacable_concept() {
std::allocator<T> a;
       std::deque<T> v(It(arr2), It(std::end(arr2)), a);
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     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);
       assert(v[0].copied == 0);
       assert(v[0].value == 42);
     }
     {
       std::deque<T> v(It(arr2), It(std::end(arr2)), a);

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

 }
 
 template <class C>
 void
 test(int P, const C& c0, const C& c2)
 {
     {
     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()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
     assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
testN(int start, int N, int M)
     }
 }
 
 template <class C>
 void
 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(c1.size() == c1_osize + c2.size());
     assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
typedef typename C::const_iterator CI;
         typedef MoveOnly* I;
         c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1));
     }
     int j = 0;
     for (CI i = c.begin(); i != c.end(); ++i, ++j)
         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;
     for (CI i = c.begin(); i != c.end(); ++i, ++j)
         assert(*i == MoveOnly(j));
 #endif
 }
 

libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp

 
 template <class C>
 void testN(int start, int N)
 {
     typedef typename C::iterator I;
     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());
     assert(c1 == c2);
     assert(std::copy(c2.cbegin(), c2.cend(), c1.begin()) == c1.end());
     assert(c1 == c2);
     assert(std::copy(c1.cbegin(), c1.cend(), RAI(c2.begin())) == RAI(c2.end()));
     assert(c1 == c2);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp

 int main(int, char**)
 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         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)
             assert(*i == n);
         assert(n == 10);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         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)
             assert(*i == 10+n);
         assert(n == 4);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         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)
             assert(*i == n);
         assert(n == 10);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         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)
             assert(*i == 10+n);
         assert(n == 4);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp

 #include "test_iterators.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         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;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
     }
 #if TEST_STD_VER >= 11
     {
         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;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp

 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         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;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c.get_allocator() == A(13));
     }
 #if TEST_STD_VER >= 11
     {
         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;
         for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c.get_allocator() == A());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp

 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         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));
         assert(i == c.before_begin());
         assert(distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
         assert(i == next(c.before_begin(), 3));
int main(int, char**)
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
 #if TEST_STD_VER >= 11
     {
         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));
         assert(i == c.before_begin());
         assert(distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
         assert(i == next(c.before_begin(), 3));

libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp

 #include "emplace_constructible.h"
 #include "container_test_types.h"
 #endif
 
 void basic_test()
 {
     {
         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;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
     {
         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 j = 0;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
     {
         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;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
 #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;
         for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
     {
         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]));
         int j = 0;
         for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
 #endif
using It = random_access_iterator<int*>;
       ++I;
       assert(I->value == 101);
       ++I;
       assert(I->value == 42);
     }
   }
   {
     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();
       assert(I->value == 42);
     }
     {
       std::list<T> v(It(arr2), It(std::end(arr2)));
       auto I = v.begin();
std::allocator<T> a;
       ++I;
       assert(I->value == 101);
       ++I;
       assert(I->value == 42);
     }
   }
   {
     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);
       auto I = v.begin();
       assert(I->value == 42);
     }
     {
       std::list<T> v(It(arr2), It(std::end(arr2)), a);
int arr2[] = {1, 101, 42};
     }
     {
       ExpectConstructGuard<int&> G(3);
       C v(It(arr2), It(std::end(arr2)));
     }
   }
   {
     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)));
     }
     {
       ExpectConstructGuard<int&> G(3);
       C v(It(arr2), It(std::end(arr2)));
     }
int arr2[] = {1, 101, 42};
     }
     {
       ExpectConstructGuard<int&> G(3);
       C v(It(arr2), It(std::end(arr2)), a);
     }
   }
   {
     using C = TCT::list<>;
-    using It = input_iterator<int*>;
+    using It = cpp17_input_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)), a);
     }
     {
       ExpectConstructGuard<int&> G(3);

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp

test(Iterator first, Iterator last)
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
 
 int main(int, char**)
 {
     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));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp

 }
 
 int main(int, char**)
 {
     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]);
     {
     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);
     test<std::vector<bool> >(a, 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);
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp

 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         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;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
int main(int, char**)
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
         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;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)

libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp

using It = forward_iterator<int*>;
       v.assign(It(arr2), It(std::end(arr2)));
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     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)));
       assert(v[0].copied == 0);
       assert(v[0].value == 42);
     }
     {
       std::vector<T> v;

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

void test(Iterator first, Iterator last) {
   for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e;
        ++i, ++first)
     assert(*i == *first);
 }
 
 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),
                           bidirectional_iterator<const int*>(an));
   test<std::vector<int> >(random_access_iterator<const int*>(a),
                           random_access_iterator<const int*>(an));
   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));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(
       bidirectional_iterator<const int*>(a),
       bidirectional_iterator<const int*>(an));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(
       random_access_iterator<const int*>(a),
       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> > >(
       bidirectional_iterator<const int*>(a),
       bidirectional_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
       random_access_iterator<const int*>(a),
       random_access_iterator<const int*>(an));
using It = forward_iterator<int*>;
       std::vector<T> v(It(arr2), It(std::end(arr2)));
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     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);
       assert(v[0].value == 42);
     }
     {
       std::vector<T> v(It(arr2), It(std::end(arr2)));
       //assert(v[0].copied == 0);
int arr2[] = {1, 101, 42};
     }
     {
       ExpectConstructGuard<int&> G(3);
       C v(It(arr2), It(std::end(arr2)));
     }
   }
   {
     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)));
     }
     {
       //ExpectConstructGuard<int&> G(3);
       //C v(It(arr2), It(std::end(arr2)), a);
     }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

 
 #endif
 
 void basic_tests() {
   {
     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),
                             bidirectional_iterator<const int*>(an), alloc);
     test<std::vector<int> >(random_access_iterator<const int*>(a),
                             random_access_iterator<const int*>(an), alloc);
     test<std::vector<int> >(a, an, alloc);
   }
 #if TEST_STD_VER >= 11
   {
     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]);
     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);
     test<std::vector<int, min_allocator<int> > >(
         bidirectional_iterator<const int*>(a),
         bidirectional_iterator<const int*>(an), alloc);
     test<std::vector<int, min_allocator<int> > >(
         random_access_iterator<const int*>(a),
Alloc a;
       std::vector<T> v(It(arr2), It(std::end(arr2)), a);
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
     }
   }
   {
     using T = EmplaceConstructibleAndMoveInsertable<int>;
-    using It = input_iterator<int*>;
+    using It = cpp17_input_iterator<int*>;
     using Alloc = std::allocator<T>;
     Alloc a;
     {
       std::vector<T> v(It(arr1), It(std::end(arr1)), a);
       assert(v[0].copied == 0);
       assert(v[0].value == 42);
     }
     {
int arr2[] = {1, 101, 42};
     }
     {
       ExpectConstructGuard<int&> G(3);
       C v(It(arr2), It(std::end(arr2)), a);
     }
   }
   {
     using C = TCT::vector<>;
-    using It = input_iterator<int*>;
+    using It = cpp17_input_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)), a);
     }
     {
       //ExpectConstructGuard<int&> G(3);

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 
 int main(int, char**)
 {
     {
         typedef std::vector<int> V;
         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);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
int main(int, char**)
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         typedef std::vector<int, limited_allocator<int, 308> > V;
         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);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
int main(int, char**)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::vector<int, min_allocator<int> > V;
         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);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
#if TEST_STD_VER >= 11
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
 #endif
 
     {
         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;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER > 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
#if TEST_STD_VER > 11
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.at(1) == "one");

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp

int main(int, char**)
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             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");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             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");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");
#if TEST_STD_VER > 11
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             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;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");
#if TEST_STD_VER > 11
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

int main(int, char**)
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             test_allocator<std::pair<const int, std::string> >(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             min_allocator<std::pair<const int, std::string> >()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
#if TEST_STD_VER >= 11
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             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),
             A{}
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp

int main(int, char**)
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             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);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);
#if TEST_STD_VER >= 11
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             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);
         assert(std::distance(eq.first, eq.second) == 2);
         std::multiset<std::string> s;
         s.insert("one");
         s.insert("four");
         CheckConsecutiveKeys<C::const_iterator>(c.find(1), c.end(), 1, s);

libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp

int main(int, char**)
             P(1),
             P(2),
             P(3),
             P(4),
             P(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);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(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);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER > 11
             T(1),
             T(2),
             T(3),
             T(4),
             T(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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
#if TEST_STD_VER > 11
             T(2),
             T(3),
             T(4),
             T(1),
             T(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);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);

libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp

int main(int, char**)
             P(1),
             P(2),
             P(3),
             P(4),
             P(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);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(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);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
#if TEST_STD_VER > 11
             T(1),
             T(2),
             T(3),
             T(4),
             T(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);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
#if TEST_STD_VER > 11
             T(2),
             T(3),
             T(4),
             T(1),
             T(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() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp

int main(int, char**)
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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_allocator<int>(10)
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
#if TEST_STD_VER >= 11
         {
             P(1),
             P(2),
             P(3),
             P(4),
             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),
             min_allocator<int>()
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp

 
 int main(int, char**) {
 {
     const char chars[] = "0123456789";
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
 
     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");
     test('x', random_access_iterator<const int*>(ints),   random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
 
     test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
 
     test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
     test<char, const int *,  wchar_t> ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
 //  test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9");
 //  test<char, const int *,  char16_t>('x',  ints,  ints+10, u"10x11x12x13x14x15x16x17x18x19");
 //  test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9");
 //  test<char, const int *,  char32_t>('x',  ints,  ints+10, U"10x11x12x13x14x15x16x17x18x19");
 
     test(mutating_delimiter(),  chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
     test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
     }
 
     {
     const wchar_t chars[] = L"0123456789";
     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");
     test(L'x', random_access_iterator<const int*>(ints),      random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
 
     test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test(L"z", ints,  ints+10,  L"10z11z12z13z14z15z16z17z18z19");
 

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp

 //   3. Append `RHS` to `LHS` and check for the expected allocation behavior.
 template <class CharT>
 void doAppendSourceAllocTest(AppendOperatorTestcase const& TC)
 {
   using namespace fs;
   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;
   Str EShort = (Ptr)TC.expected_result();
   assert(RShort.size() >= 2);
   CharT c = RShort.back();
   RShort.append(100, c);
   EShort.append(100, c);

 
 template <class CharT>
 void doAppendSourceTest(AppendOperatorTestcase const& TC)
 {
   using namespace fs;
   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();
   // basic_string
   {
     path Result(L);
     Str RHS(R);
     path& Ref = (Result /= RHS);

 void test_sfinae()
 {
   using namespace fs;
   {
     using It = const char* const;
     static_assert(has_append<It>(), "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = cpp17_input_iterator<const char*>;
     static_assert(has_append<It>(), "");
   }
   {
     struct Traits {
       using iterator_category = std::input_iterator_tag;
       using value_type = const char;
       using pointer = const char*;
       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>(), "");
   }
   {
     using It = output_iterator<const char*>;
     static_assert(!has_append<It>(), "");
 
   }
   {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp

path p; PathReserve(p, Size + 1);
       assert(&pref == &p);
     }
     assert(p.native() == Expect);
     assert(p.string<CharT>() == TestPath);
   }
   //////////////////////////////////////////////////////////////////////////////
   // Iterators
   {
-    using It = input_iterator<const CharT*>;
+    using It = cpp17_input_iterator<const CharT*>;
     path p; PathReserve(p, Size + 1);
     It it(TestPath);
     {
       // Iterators cannot be used with code_cvt directly. This assignment
       // may allocate if it's larger than a "short-string".
       path& pref = (p = it);
       assert(&pref == &p);
     }
     assert(p.native() == Expect);
     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);
     {
       path& pref = p.assign(it);
       assert(&pref == &p);
     }
     assert(p.native() == Expect);
     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);
     {
       path& pref = p.assign(it, e);
       assert(&pref == &p);
     }
     assert(p.native() == Expect);

 void test_sfinae() {
   using namespace fs;
   {
     using It = const char* const;
     static_assert(std::is_assignable<path, It>::value, "");
     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>(), "");
   }
   {
     struct Traits {
       using iterator_category = std::input_iterator_tag;
       using value_type = const char;
       using pointer = const char*;
       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 It = output_iterator<const char*>;
     static_assert(!std::is_assignable<path, It>::value, "");
     static_assert(!has_assign<It>(), "");
 

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp

 //   3. Concat `RHS` to `LHS` and check for the expected allocation behavior.
 template <class CharT>
 void doConcatSourceAllocTest(ConcatOperatorTestcase const& TC)
 {
   using namespace fs;
   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;
   std::size_t ReserveSize = StrLen(E) + 1;
   // basic_string
   {
     path LHS(L); PathReserve(LHS, ReserveSize);

 
 template <class CharT>
 void doConcatSourceTest(ConcatOperatorTestcase const& TC)
 {
   using namespace fs;
   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;
   // basic_string
   {
     path LHS(L);
     Str RHS(R);
     path& Ref = (LHS += RHS);
using namespace fs;
     static_assert(has_concat_op<char16_t>(), "");
     static_assert(has_concat_op<const char16_t>(), "");
   }
   {
     using It = const char* const;
     static_assert(has_concat<It>(), "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = cpp17_input_iterator<const char*>;
     static_assert(has_concat<It>(), "");
   }
   {
     struct Traits {
       using iterator_category = std::input_iterator_tag;
       using value_type = const char;
       using pointer = const char*;
       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>(), "");
   }
   {
     using It = output_iterator<const char*>;
     static_assert(!has_concat<It>(), "");
   }
   {
     static_assert(!has_concat<int>(0), "");

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp

void RunTestCaseImpl(MultiStringType const& MS, Args... args) {
   }
   {
     path p(TestPath, TestPathEnd, args...);
     assert(p.native() == Expect);
     assert(p.string<CharT>() == TestPath);
   }
   // 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);
   }
 }
 
 template <class CharT, class ...Args>
 void RunTestCase(MultiStringType const& MS) {
   RunTestCaseImpl<CharT>(MS);
   RunTestCaseImpl<CharT>(MS, fs::path::format::auto_format);
   RunTestCaseImpl<CharT>(MS, fs::path::format::native_format);
   RunTestCaseImpl<CharT>(MS, fs::path::format::generic_format);
   RunTestCaseImpl<CharT>(MS, fs::path::auto_format);
   RunTestCaseImpl<CharT>(MS, fs::path::native_format);
   RunTestCaseImpl<CharT>(MS, fs::path::generic_format);
 }
 
 void test_sfinae() {
   using namespace fs;
   {
     using It = const char* const;
     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, "");
   }
   {
     struct Traits {
       using iterator_category = std::input_iterator_tag;
       using value_type = const char;
       using pointer = const char*;
       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, "");
   }
   {
     using It = output_iterator<const char*>;
     static_assert(!std::is_constructible<path, It>::value, "");
 
   }
   {

libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp

void check_advance(It it, Distance n, It result)
     std::advance(it, n);
     assert(it == result);
 }
 
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     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>(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
     check_advance<Distance>(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s));
     check_advance<Distance>(s+5, 5, s+10);
     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));
 
     return true;
 }
 
 int main(int, char**)
 {
     tests();
 #if TEST_STD_VER >= 17
     static_assert(tests(), "");
 #endif
     return 0;
 }

libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp

void check_distance(It first, It last, typename std::iterator_traits<It>::difference_type dist)
     typedef typename std::iterator_traits<It>::difference_type Difference;
     static_assert(std::is_same<decltype(std::distance(first, last)), Difference>::value, "");
     assert(std::distance(first, last) == dist);
 }
 
 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);
     check_distance(s, s+10, 10);
     return true;
 }
 
 int main(int, char**)
 {
     tests();
 #if TEST_STD_VER >= 17
     static_assert(tests(), "");
 #endif
     return 0;
 }

libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp

 {
     static_assert(std::is_same<decltype(std::next(it)), It>::value, "");
     assert(std::next(it) == result);
 }
 
 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, random_access_iterator<const char*>(s+10));
     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));
     check_next_1(s, s+1);
 
     return true;
 }
 
 int main(int, char**)
 {
     tests();
 #if TEST_STD_VER >= 17
     static_assert(tests(), "");
 #endif
     return 0;
 }

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

 static_assert(
     std::same_as<LegacyRandomAccessSpecializedTraits::reference, short&>);
 static_assert(
     std::same_as<LegacyRandomAccessSpecializedTraits::pointer, short*>);
 static_assert(!has_iterator_concept_v<LegacyRandomAccessSpecializedTraits>);
 
 // 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>);
 static_assert(std::same_as<InputTestItereatorTraits::difference_type, std::ptrdiff_t>);
 static_assert(std::same_as<InputTestItereatorTraits::reference, int&>);
 static_assert(std::same_as<InputTestItereatorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<InputTestItereatorTraits>);
 

libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp

 // using iter_reference_t = decltype(*declval<T&>());
 
 #include <iterator>
 
 #include <concepts>
 
 #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&>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_iterator.compile.pass.cpp

 
 // template<class T>
 // concept input_iterator;
 
 #include <iterator>
 
 #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 {
   using value_type = int;
   using difference_type = std::ptrdiff_t;
 
   no_explicit_iter_concept() = default;
 

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp

 
 #include "test_iterators.h"
 
 static_assert(std::input_or_output_iterator<int*>);
 static_assert(std::input_or_output_iterator<int const*>);
 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*> >);
 static_assert(std::input_or_output_iterator<forward_iterator<int volatile*> >);
 static_assert(std::input_or_output_iterator<forward_iterator<int const volatile*> >);
 
 static_assert(std::input_or_output_iterator<bidirectional_iterator<int*> >);
 static_assert(std::input_or_output_iterator<bidirectional_iterator<int const*> >);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp

test(It i)
     const std::move_iterator<It> r(i);
     assert(std::make_move_iterator(i) == r);
 }
 
 int main(int, char**)
 {
     {
     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));
     test(s+5);
     }
     {
     int a[] = {1,2,3,4};
     TEST_IGNORE_NODISCARD std::make_move_iterator(a+4);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp

test(It l, It r, bool x)
     const std::move_iterator<It> r1(l);
     const std::move_iterator<It> r2(r);
     assert((r1 == r2) == x);
 }
 
 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);
     test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), false);
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp

test(It l, It r, bool x)
     const std::move_iterator<It> r1(l);
     const std::move_iterator<It> r2(r);
     assert((r1 != r2) == x);
 }
 
 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);
     test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), true);
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
     test(s, s, false);
     test(s, s+1, true);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp

 
 struct Base {};
 struct Derived : Base {};
 
 int main(int, char**)
 {
     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));
     test<Base*>(&d);
 
 #if TEST_STD_VER > 14
     {
     constexpr const Derived *p = nullptr;
     constexpr std::move_iterator<const Derived *>     it1 = std::make_move_iterator(p);
     constexpr std::move_iterator<const Base *>        it2(it1);
     static_assert(it2.base() == p);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp

 test()
 {
     std::move_iterator<It> r;
     (void)r;
 }
 
 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*> >();
     test<char*>();
 
 #if TEST_STD_VER > 14
     {
     constexpr std::move_iterator<const char *> it;
     (void)it;
     }
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp

 {
     std::move_iterator<It> r(i);
     assert(r.base() == i);
 }
 
 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));
     test(s);
 
 #if TEST_STD_VER > 14
     {
     constexpr const char *p = "123456789";
     constexpr std::move_iterator<const char *> it(p);
     static_assert(it.base() == p);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp

test(It i, It x)
     assert(r.base() == x);
     assert(rr.base() == i);
 }
 
 int main(int, char**)
 {
     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));
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
     test(s, s+1);
 
 #if TEST_STD_VER > 14
     {

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp

test(It i, It x)
     std::move_iterator<It>& rr = ++r;
     assert(r.base() == x);
     assert(&rr == &r);
 }
 
 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));
     test(s, s+1);
 
 #if TEST_STD_VER > 14
     {
     constexpr const char *p = "123456789";

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp

 
 struct Base {};
 struct Derived : Base {};
 
 int main(int, char**)
 {
     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));
     test<Base*>(&d);
 #if TEST_STD_VER > 14
     {
     using BaseIter    = std::move_iterator<const Base *>;
     using DerivedIter = std::move_iterator<const Derived *>;

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

#if TEST_STD_VER > 17
     }
 #else
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 #endif
 }
 
 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*> >();
     test<char*>();
 #if TEST_STD_VER >= 11
     {
         typedef DummyIt<int, int> T;
         typedef std::move_iterator<T> It;

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : 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
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     {
         const my_facet f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facet f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : 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
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     {
         const my_facet f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
         noshowbase(ios);
     }
     {
         const my_facet f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

 // we test. To avoid this test becoming entirely stale, we just disable
 // the parts that fail.
 //
 // See https://llvm.org/PR45739 for the bug tracking this.
 #if defined(__APPLE__)
 #   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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : 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
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     {
         const my_facet f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
         }
     }
     {
         const my_facet f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
 #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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
 #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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
 #endif
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
 #endif
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 5);
             assert(err == std::ios_base::goodbit);
             assert(ex == 0);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
 #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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 6);
             assert(err == std::ios_base::goodbit);
             assert(ex == -1);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
 #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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
 #endif
 #if !defined(APPLE_FIXME)
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
 #endif
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 14);
             assert(err == std::ios_base::goodbit);
             assert(ex == -123456789);
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : 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
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     {
         const my_facet f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facet f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 0);
             assert(err == std::ios_base::failbit);
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp

 #include <ios>
 #include <streambuf>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : 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
 {
 public:
     explicit my_facetw(std::size_t refs = 0)
         : Fw(refs) {}
 };
ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, false>(loc_name)));
     ios.imbue(std::locale(ios.getloc(),
                           new std::moneypunct_byname<wchar_t, true>(loc_name)));
     {
         const my_facet f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
         }
     }
     {
         const my_facet f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             noshowbase(ios);
         }
         {   // 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()),
                                                 false, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
         }
     }
     {
         const my_facetw f(1);
         // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             noshowbase(ios);
         }
         {   // 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()),
                                                 true, ios, err, ex);
             assert(iter.base() == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     {
         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);
         assert(b == true);
     }
     {
         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);
         assert(b == false);
     }
     {
         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);
         assert(b == true);
     }
     {
         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);
         assert(b == false);
     }
     boolalpha(ios);
     {
         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);
         assert(b == false);
     }
     {
         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);
         assert(b == true);
     }
     {
         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);
         assert(b == false);
     }
     ios.imbue(std::locale(ios.getloc(), new p1));
     {
         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);
         assert(b == true);
     }
     {
         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);
         assert(b == false);
     }
     {
         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);
         assert(b == true);
     }
     ios.imbue(std::locale(ios.getloc(), new p2));
     {
         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);
         assert(b == true);
     }
     {
         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);
         assert(b == false);
     }
     {
         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);
         assert(b == false);
     }
     {
         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);
         assert(b == true);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp

 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <cmath>
 #include "test_macros.h"
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
int main(int, char**)
     const my_facet f(1);
     std::ios ios(0);
     double v = -1;
     {
         const char str[] = "123";
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == -123);
     }
     {
         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);
         assert(v == 123.5);
     }
     {
         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);
         assert(v == 125e-1);
     }
     {
         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);
         assert(v == hexfloat<double>(0x125, 0, -1));
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(v == 123);
     }
     {
         // See PR11871
         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);
         assert(v == 2);
     }
     {
         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);
         assert(v == HUGE_VAL);
     }
     {
         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);
         assert(v == -HUGE_VAL);
     }
     ios.imbue(std::locale(std::locale(), new my_numpunct));
     {
         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);
         assert(v == 123456789.125);
     }
     {
         v = -1;
         const char str[] = "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_"
                            "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_"
                            "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_"
                            "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_"
                            "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_"
                            "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);
     }
     {
         // See PR15445
         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);
         assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp

 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <cmath>
 #include "test_macros.h"
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
 
 
 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     float v = -1;
     {
         const char str[] = "123";
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == -123);
     }
     {
         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);
         assert(v == 123.5);
     }
     {
         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);
         assert(v == 125e-1);
     }
     {
         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);
         assert(v == hexfloat<float>(0x125, 0, -1));
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(v == HUGE_VALF);
     }
     {
         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);
         assert(v == -HUGE_VALF);
 
     }
     {
         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);
         assert(v == 2);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp

 #include <locale>
 #include <ios>
 #include <cassert>
 #include <limits>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
int main(int, char**)
     std::ios ios(0);
     long v = -1;
     const std::ios_base::fmtflags zf = static_cast<std::ios_base::fmtflags>(0);
     {
         const char str[] = "123";
         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(v == 123);
     }
     {
         const char str[] = "-123";
         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);
         assert(v == -123);
     }
     {
         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);
         assert(v == 83);
     }
     {
         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);
         assert(v == 291);
     }
     {
         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);
         assert(v == 291);
     }
     {
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == 291);
     }
     {
         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);
         assert(v == 83);
     }
     {
         // See PR11871
         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);
         assert(v == 2);
     }
     dec(ios);
     ios.imbue(std::locale(std::locale(), new my_numpunct));
     {
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 1);
     }
     {
         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);
         assert(v == 12);
     }
     {
         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);
         assert(v == 12);
     }
     {
         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);
         assert(v == 12);
     }
     {
         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);
         assert(v == 12);
     }
     {
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == 1234);
     }
     {
         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);
         assert(v == 1234);
     }
     {
         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);
         assert(v == 1234);
     }
     {
         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);
         assert(v == 12345);
     }
     {
         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);
         assert(v == 123456);
     }
     {
         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);
         assert(v == 123456);
     }
     {
         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);
         assert(v == 1234567);
     }
     {
         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);
         assert(v == 1234567890);
     }
     {
         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);
         assert(v == -1234567890);
     }
     {
         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);
         assert(v == 1234567890);
     }
     {
         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);
         assert(v == 1234567890);
     }
     {
         v = -1;
         const char str[] = "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_"
                            "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_"
                            "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_"
                            "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_"
                            "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_"
                            "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);
         assert(v == std::numeric_limits<long>::max());
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp

 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <cmath>
 #include "test_macros.h"
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
 
 
 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     long double v = -1;
     {
         const char str[] = "123";
         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);
         assert(v == 123);
     }
     {
         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);
         assert(v == -123);
     }
     {
         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);
         assert(v == 123.5);
     }
     {
         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);
         assert(v == 125e-1);
     }
     {
         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);
         assert(v == hexfloat<long double>(0x125, 0, -1));
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(v == -INFINITY);
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(std::isnan(v));
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == INFINITY);
     }
     {
         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);
         assert(v == 304888344611713860501504000000.0L);
     }
     {
         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);
         assert(v == HUGE_VALL);
     }
     {
         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);
         assert(v == -HUGE_VALL);
     }
     {
         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);
         assert(v == 2);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     long long v = -1;
     {
         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);
         assert(v == 0);
     }
     {
         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);
         assert(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);
         assert(v == -1);
     }
     hex(ios);
     {
         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);
         assert(v == 0x7FFFFFFFFFFFFFFFLL);
     }
     {
         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);
         const long long expect = 0x8000000000000000LL;
         assert(v == expect);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
 
 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     {
         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);
         assert(p == 0);
     }
     {
         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);
         assert(p == (void*)0x73);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     unsigned int v = static_cast<unsigned int>(-1);
     {
         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);
         assert(v == 0);
     }
     {
         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);
         assert(v == 1);
     }
     hex(ios);
     {
         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);
         assert(v == 0xFFFFFFFF);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     unsigned long v = static_cast<unsigned long>(-1);
     {
         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);
         assert(v == 0);
     }
     {
         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);
         assert(v == 1);
     }
     hex(ios);
     {
         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);
         assert(v == 0xFFFFFFFF);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     unsigned long long v = static_cast<unsigned long long>(-1);
     {
         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);
         assert(v == 0);
     }
     {
         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);
         assert(v == 1);
     }
     hex(ios);
     {
         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);
         assert(v == 0xFFFFFFFFFFFFFFFFULL);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp

 
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
     unsigned short v = static_cast<unsigned short>(-1);
     {
         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);
         assert(v == 0);
     }
     {
         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);
         assert(v == 1);
     }
     hex(ios);
     {
         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);
         assert(v == 0xFFFF);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp

 #include <sstream>
 #include "test_iterators.h"
 #include "test_macros.h"
 
 #ifdef TEST_COMPILER_C1XX
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };

 template <class T>
 void test_neg_one() {
     const my_facet f(1);
     std::ios ios(0);
     T v = static_cast<T>(42);
     {
         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);
         assert(v == T(-1));
     }
     v = 42;
     {
         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);
         assert(v == 0);
     }
 }
 
 template <class T>
 void test_negate() {
     typedef typename std::make_signed<T>::type SignedT;
     const my_facet f(1);
     std::ios ios(0);
     T v = 42;
     {
         T value = std::numeric_limits<SignedT>::max();
         ++value;
         std::string std_str = make_neg_string(value);
         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);
         T expected = -value;
         assert(v == expected);
     }
     v = 42;
     {
         T value = std::numeric_limits<SignedT>::max();
         ++value;
         ++value;
         std::string std_str = make_neg_string(value);
         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);
         T expected = -value;
         assert(v == expected);
     }
     v = 42;
     {
         T value = std::numeric_limits<T>::max();
         std::string std_str = make_neg_string(value);
         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);
         T expected = -value;
         assert(v == expected);
     }
     v = 42;
     {
         std::string std_str = make_neg_string(std::numeric_limits<T>::max());
         std_str.back()++;
         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);
         assert(v == T(-1));
     }
 }
 
 int main(int, char**)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)
         : F(nm, refs) {}
 };

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)
         : F(nm, refs) {}
 };

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp

 #include <locale>
 #include <cassert>
 #include <ios>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp

 #include <locale>
 #include <cassert>
 #include <ios>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp

 
 #include <locale>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp

 #include <locale>
 #include <cassert>
 #include <ios>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp

 #include <locale>
 #include <cassert>
 #include <ios>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(const std::string& nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp

 
 // dateorder date_order() const;
 
 #include <locale>
 #include <cassert>
 #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
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
 
 int main(int, char**)
 {
     const my_facet f(1);
     assert(f.date_order() == std::time_base::mdy);
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp

 //          ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #include <ios>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp

 //          ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #include <ios>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp

 //     const char_type *fmt, const char_type *fmtend) const;
 
 #include <locale>
 #include <cassert>
 #include <ios>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp

 // get_monthname(iter_type s, iter_type end, ios_base& str,
 //               ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp

 // get_monthname(iter_type s, iter_type end, ios_base& str,
 //               ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp

 // iter_type get(iter_type s, iter_type end, ios_base& f,
 //               ios_base::iostate& err, tm *t, char format, char modifier = 0) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp

 // get_time(iter_type s, iter_type end, ios_base& str,
 //          ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp

 // get_time(iter_type s, iter_type end, ios_base& str,
 //          ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp

 // get_weekday(iter_type s, iter_type end, ios_base& str,
 //             ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp

 // get_weekday(iter_type s, iter_type end, ios_base& str,
 //             ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp

 //                    ios_base::iostate& err, tm* t) const;
 
 #include <locale>
 #include <cassert>
 #include <ios>
 #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;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

test()
     test(Iter(ia), Iter(ia+2), 10, 13);
     test(Iter(ia), Iter(ia+sa), 0, 21);
     test(Iter(ia), Iter(ia+sa), 10, 31);
 }
 
 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<const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

test()
     test(Iter(ia), Iter(ia+2), 10, 20);
     test(Iter(ia), Iter(ia+sa), 1, 720);
     test(Iter(ia), Iter(ia+sa), 10, 7200);
 }
 
 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<const int*>();
 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

public:
     TEST_CONSTEXPR_CXX20 void operator=(const X& x) {i_ = x.i_;}
 };
 
 #endif
 
 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<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*> >();

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

 };
 
 #endif
 
 
 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<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*> >();

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), 1, std::multiplies<>(), mRes, mRes + i);
     }
 }
 
 TEST_CONSTEXPR_CXX20 bool
 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*> >();
     test<const int*>();
     test<      int*>();
 
 //  Make sure that the calculations are done using the init typedef
     {

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp

test()
     test(Iter1(a), Iter1(a+2), Iter2(b), 10, 26);
     test(Iter1(a), Iter1(a+sa), Iter2(b), 0, 56);
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66);
 }
 
 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<const int*, const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

test()
     test(Iter1(a), Iter1(a+2), Iter2(b), 10, 490);
     test(Iter1(a), Iter1(a+sa), Iter2(b), 1, 117649);
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490);
 }
 
 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<const int*, const int*>();
 
 #if TEST_STD_VER > 17
     test_use_move();
 #endif // TEST_STD_VER > 17

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp

test()
     assert(base(r) == ib + s);
     for (unsigned i = 0; i < s; ++i)
         assert(ib[i] == ir[i]);
 }
 
 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<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*> >();

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

test()
     assert(base(r) == ib + s);
     for (unsigned i = 0; i < s; ++i)
         assert(ib[i] == ir[i]);
 }
 
 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<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*> >();

libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp

 test()
 {
     test_return_type<char>();
     test_return_type<int>();
     test_return_type<unsigned long>();
     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<const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp

test()
     test_return_type<char, int>();
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     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<const int*>();
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp

test()
     test_return_type<char, int>();
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     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<const int*>();
 
 //  Make sure the math is done using the correct type
     {
     auto v = {1, 2, 3, 4, 5, 6, 7, 8};

libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     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<const int*>();
     test<      int*>();
 
     return true;
 }

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

test()
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
     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<const int*>();
     test<      int*>();
 
 //  Make sure the math is done using the correct type
     {

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

test()
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
     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*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
     test<const int*,       unsigned int *>();
     test<      int*, const unsigned int *>();

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

test()
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
     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*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
     test<const int*,       unsigned int *>();
     test<      int*, const unsigned int *>();

libcxx/test/std/ranges/range.range/helper_aliases.compile.pass.cpp

 
 // template<range R>
 // using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
 #include <ranges>
 
 #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*> >);

libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp

 #include <ranges>
 
 #include <concepts>
 
 #include "test_range.h"
 
 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*> >);

libcxx/test/std/ranges/range.range/range.compile.pass.cpp

 #include <ranges>
 
 #include <vector>
 
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
-static_assert(stdr::range<test_range<> >);
+static_assert(stdr::range<test_range<cpp20_input_iterator> >);
 
 struct incompatible_iterators {
   int* begin();
   long* end();
 };
 static_assert(!stdr::range<incompatible_iterators>);
 
 struct int_begin_int_end {

libcxx/test/std/ranges/range.range/sentinel_t.compile.pass.cpp

 
 #include <concepts>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 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*> >);

libcxx/test/std/ranges/range.refinements/common_range.compile.pass.cpp

 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 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;
   int const* end() const;
 };
 static_assert(stdr::range<subtly_not_common> && !stdr::common_range<subtly_not_common>);
 static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>);
 

libcxx/test/std/ranges/range.refinements/input_range.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // template<range _Rp>
 // concept input_range;
 
 #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>);

libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp

 #include <regex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 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;
 
     r2.assign(I(s4.begin()), I(s4.end()));
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
 

libcxx/test/std/strings/basic.string/cpp17_input_iterator.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef INPUT_ITERATOR_H
 #define INPUT_ITERATOR_H
 
 #include <iterator>
 
 template <class It>
-class input_iterator
+class cpp17_input_iterator
 {
     It it_;
 public:
     typedef typename std::input_iterator_tag                   iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     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);}
 };
 
 #endif // INPUT_ITERATOR_H

libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

using TestSizeT = test_allocator<char>::size_type;
     using WStr = std::basic_string<wchar_t,
                                   std::char_traits<wchar_t>,
                                   test_allocator<wchar_t>>;
     std::basic_string w(L"abcdef", test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(w), WStr);
     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);
     assert(s == "abc");
   }
   { // (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);
     assert(s == L"abc");
   }
   { // Testing (9)
     const std::string sin("abc");
     std::basic_string s(sin);

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

 
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
 template <class It>
 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
int main(int, char**)
     test(s, s+1, A(2));
 
     test(s, s+10);
     test(s, s+10, A(2));
 
     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
     {
     typedef min_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
     test(s, s);
     test(s, s, A());
 
     test(s, s+1);
     test(s, s+1, A());
 
     test(s, s+10);
     test(s, s+10, A());
 
     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
     {
       static_assert((!std::is_constructible<std::string, std::string,
                                             std::string>::value),
                     "");
       static_assert(
           (!std::is_constructible<std::string, std::string, std::string,
                                   std::allocator<char> >::value),
           "");
     }
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

 
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #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**)
 {
     {
     const char* s = "12345678901234";
     std::basic_string s1(s, s+10);  // Can't use {} here
     using S = decltype(s1); // what type did we get?

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 #include <cstddef>
 
 #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**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
     using S = decltype(s1); // what type did we get?

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

 #include <string>
 #include <string_view>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #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**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
     using S = decltype(s1); // what type did we get?

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

int main(int, char**)
     test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S("12345678901234567890"));
     test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
     test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
     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
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
#if TEST_STD_VER >= 11
     test(S("1234567890"), s, s+52, S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S("12345678901234567890"));
     test(S("12345678901234567890"), s, s+1, S("12345678901234567890""A"));
     test(S("12345678901234567890"), s, s+10, S("12345678901234567890""ABCDEFGHIJ"));
     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
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // 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_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

int main(int, char**)
     test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S());
     test(S("12345678901234567890"), s, s+1, S("A"));
     test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
     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
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
     test(S(), s, s+1, S("A"));
#if TEST_STD_VER >= 11
     test(S("1234567890"), s, s+52, S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
     test(S("12345678901234567890"), s, s, S());
     test(S("12345678901234567890"), s, s+1, S("A"));
     test(S("12345678901234567890"), s, s+10, S("ABCDEFGHIJ"));
     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
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // 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_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

int main(int, char**)
     test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
 
     test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
     test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
     test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
     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
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), 0, s, s, S());
     test(S(), 0, s, s+1, S("A"));
#if TEST_STD_VER >= 11
     test(S("1234567890"), 8, s, s+52, S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
 
     test(S("12345678901234567890"), 3, s, s, S("12345678901234567890"));
     test(S("12345678901234567890"), 3, s, s+1, S("123A45678901234567890"));
     test(S("12345678901234567890"), 15, s, s+10, S("123456789012345ABCDEFGHIJ67890"));
     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
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // 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_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
     test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
#endif
     test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("\0hello", 6));
     test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("\0Lorem ipsum dolor sit amet, consectetur/", 41));
     test(s_othertype, 1, first + 2, first + 5, std::string("hlloello"));
     }
 
   { // 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;
     s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

#if TEST_STD_VER >= 11
     test7<S>();
     test8<S>();
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // 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());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     assert(values[2] == 0);
     assert(values[3] == 4);
     assert(values[4] == 5);
 #endif
 }
 
 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};
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
     auto ret = std::uninitialized_move(It(values), It(values + 1), FIt(p));
     assert(ret == FIt(p +1));
     assert(Counted::constructed == 1);

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     assert(values[2] == 0);
     assert(values[3] == 4);
     assert(values[4] == 5);
 #endif
 }
 
 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};
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
     auto ret = std::uninitialized_move_n(It(values), 1, FIt(p));
     assert(ret.first == It(values +1));
     assert(ret.second == FIt(p +1));

libcxx/test/support/test_iterators.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ITERATORS_H
public:
     TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
         {output_iterator tmp(*this); ++(*this); return tmp;}
 
     template <class T>
     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;
     typedef typename Traits::difference_type                   difference_type;
     typedef It                                                 pointer;
     typedef typename Traits::reference                         reference;
 
     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>
     void operator,(T const &) DELETE_FUNCTION;
 };
 
 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);
 }
 
 template <class It>
 class forward_iterator
 {
     It it_;
public:
     }
 };
 #endif
 
 template <class Iter>
 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(); }
 
 template <class Iter>
 inline TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>

libcxx/test/support/test_range.h

 #error "test/suppoort/test_range.h" can only be included in builds supporting ranges
 #endif
 
 struct sentinel {
   bool operator==(std::input_or_output_iterator auto const&) const;
 };
 
 // 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();
   I<int const*> begin() const;
   sentinel end();
   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*> begin() const;
   I<int*> end();
   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();
   I<int*> end();
 };
 
 // clang-format on
 
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H