[libc++] Removes base member from tests.

[Mordante]

Summary

Change the tests to use the base friend function instead of members.
Also changed some types to have a base friends instead of members.

[ldionne]

The direction LGTM, I think Arthur has some comments.

[• Quuxplusone]

LGTM % comments; thanks for cleaning up these TODOs!
(@ldionne via Discord says: "I'm fine with this!")

libcxx/test/std/iterators/predef.iterators/counted.iterator/assign.pass.cpp

32–41

Since this is just an ad-hoc iterator used in this one test, I'd prefer to s/class/struct/, make the it_ member public, and then use x.it_ instead of base(x) throughout. The only reason we like to use base(x) in general is for genericity — it works for both raw pointers and test-iterators. Here, IIUC, we care only about this one type, no?

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.iter.pass.cpp

60–82

Perhaps in a separate commit, but how about you just eliminate lines 60-82? They're completely redundant with lines 36-58. (The only difference is whether the variable being constructed is const; but the ctor being tested here cannot possibly care about its target's constness.)

libcxx/test/std/iterators/predef.iterators/iterators.common/types.h

162

I suggest renaming to base_ instead. (Ditto in the other places you do this.)

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

426–430

Honestly these should all be like

assert(std::ranges::rbegin(a) == std::reverse_iterator(bidirectional_iterator<int*>(a.e)));

but since this transformation is purely mechanical, no action required AFAIC.

libcxx/test/std/ranges/range.utility/view.interface/view.interface.pass.cpp

139–142

Style nit: https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/#explicitness-all-of-your-constru

libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp

32–35

Consider refactoring to

auto r = m.format(cpp17_output_iterator<char*>(out),
                    fmt, fmt + std::char_traits<char>::length(fmt));
assert(base(r) == out + 58);

[Mordante]

Thanks for the reviews!

libcxx/test/std/iterators/predef.iterators/counted.iterator/assign.pass.cpp

32–41

I prefer to keep it as is since the test also uses a forward_iterator (line 72). Having base for this iterator makes that part of the test using one style instead of mixing base(foo) and foo.it_.

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.iter.pass.cpp

60–82

Good point, but I prefer a separate commit.

libcxx/test/std/iterators/predef.iterators/iterators.common/types.h

162

I was doubting between end and base_ so will change it.

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

426–430

I wouldn't mind to do that in a followup.

[Mordante]

Addresses review comments.
Rebased on main to fix CI.

[Mordante]

Rebased and fixes merge conflicts.
Fix CI issues by testing with all locales on my system.

[Mordante]

Rebased and attempt to fix Apple CI.

[Mordante]

Fix CI

[ldionne]

LGTM. The Apple CI failure seemed unrelated (I think it's a flake that I'll have to investigate).

[Mordante]

Rebase and test whether CI passes.

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<cpp17_output_iterator<int*>,  int*> P;
         P p = std::partition_copy(cpp17_input_iterator<const int*>(std::begin(ia)),
                                   cpp17_input_iterator<const int*>(std::end(ia)),
                                   cpp17_output_iterator<int*>(r1), r2, is_odd());
-        assert(p.first.base() == r1 + 4);
+        assert(base(p.first) == 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);
         assert(r2[1] == 4);
         assert(r2[2] == 6);

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

void test() {
   const int *oa1 = Expectations::oa1;
   ((void)oa1); // Prevent unused warning
   const int *oa2 = Expectations::oa2;
   ((void)oa2); // Prevent unused warning
   std::minstd_rand g;
   SampleIterator end = std::sample(PopulationIterator(ia),
                                    PopulationIterator(ia + is),
                                    SampleIterator(oa), os, g);
-  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  assert(static_cast<std::size_t>(base(end) - oa) == std::min(os, is));
   // sample() is deterministic but non-reproducible;
   // its results can vary between implementations.
   LIBCPP_ASSERT(std::equal(oa, oa + os, oa1));
   end = std::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, std::move(g));
-  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  assert(static_cast<std::size_t>(base(end) - oa) == std::min(os, is));
   LIBCPP_ASSERT(std::equal(oa, oa + os, oa2));
 }
 
 template <template<class...> class PopulationIteratorType, class PopulationItem,
           template<class...> class SampleIteratorType, class SampleItem>
 void test_empty_population() {
   typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
   typedef SampleIteratorType<SampleItem *> SampleIterator;
   PopulationItem ia[] = {42};
   const unsigned os = 4;
   SampleItem oa[os];
   std::minstd_rand g;
   SampleIterator end =
       std::sample(PopulationIterator(ia), PopulationIterator(ia),
                                 SampleIterator(oa), os, g);
-  assert(end.base() == oa);
+  assert(base(end) == oa);
 }
 
 template <template<class...> class PopulationIteratorType, class PopulationItem,
           template<class...> class SampleIteratorType, class SampleItem>
 void test_empty_sample() {
   typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
   typedef SampleIteratorType<SampleItem *> SampleIterator;
   PopulationItem ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   const unsigned is = sizeof(ia) / sizeof(ia[0]);
   SampleItem oa[1];
   std::minstd_rand g;
   SampleIterator end =
       std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
                                 SampleIterator(oa), 0, g);
-  assert(end.base() == oa);
+  assert(base(end) == oa);
 }
 
 template <template<class...> class PopulationIteratorType, class PopulationItem,
           template<class...> class SampleIteratorType, class SampleItem>
 void test_small_population() {
   // The population size is less than the sample size.
   typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
   typedef SampleIteratorType<SampleItem *> SampleIterator;
   PopulationItem ia[] = {1, 2, 3, 4, 5};
   const unsigned is = sizeof(ia) / sizeof(ia[0]);
   const unsigned os = 8;
   SampleItem oa[os];
   const SampleItem oa1[] = {1, 2, 3, 4, 5};
   std::minstd_rand g;
   SampleIterator end = std::sample(PopulationIterator(ia),
                                    PopulationIterator(ia + is),
                                    SampleIterator(oa), os, g);
-  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  assert(static_cast<std::size_t>(base(end) - oa) == std::min(os, is));
   typedef typename std::iterator_traits<PopulationIterator>::iterator_category PopulationCategory;
   if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) {
-    assert(std::equal(oa, end.base(), oa1));
+    assert(std::equal(oa, base(end), oa1));
   } else {
-    assert(std::is_permutation(oa, end.base(), oa1));
+    assert(std::is_permutation(oa, base(end), oa1));
   }
 }
 
 int main(int, char**) {
   test<cpp17_input_iterator, int, random_access_iterator, int>();
   test<forward_iterator, int, cpp17_output_iterator, int>();
   test<forward_iterator, int, random_access_iterator, int>();
 

libcxx/test/std/iterators/predef.iterators/counted.iterator/assign.pass.cpp

 
 public:
     typedef          std::input_iterator_tag                      iterator_category;
     typedef int                                                   value_type;
     typedef typename std::iterator_traits<int *>::difference_type difference_type;
     typedef int *                                                 pointer;
     typedef int &                                                 reference;
 
-    constexpr int *base() const {return it_;}
+    friend constexpr int *base(const AssignableFromIter& i) {return i.it_;}
 
     AssignableFromIter() = default;
     explicit constexpr AssignableFromIter(int *it) : it_(it) {}
-    constexpr AssignableFromIter(const forward_iterator<int*>& it) : it_(it.base()) {}
+    constexpr AssignableFromIter(const forward_iterator<int*>& it) : it_(base(it)) {}
 
     constexpr AssignableFromIter& operator=(const forward_iterator<int*> &other) {
-      it_ = other.base();
+      it_ = base(other);
       return *this;
     }
 
     constexpr reference operator*() const {return *it_;}
 
     constexpr AssignableFromIter& operator++() {++it_; return *this;}
     constexpr AssignableFromIter operator++(int)
         {AssignableFromIter tmp(*this); ++(*this); return tmp;}
 };
 
static_assert( std::is_assignable_v<std::counted_iterator<forward_iterator<int*>>,
                                         std::counted_iterator<forward_iterator<int*>>>);
     static_assert(!std::is_assignable_v<std::counted_iterator<forward_iterator<int*>>,
                                         std::counted_iterator<random_access_iterator<int*>>>);
   }
 
   {
     std::counted_iterator iter1(AssignableFromIter{buffer}, 8);
     std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
-    assert(iter1.base().base() == buffer);
+    assert(base(iter1.base()) == buffer);
     assert(iter1.count() == 8);
     std::counted_iterator<AssignableFromIter>& result = (iter1 = iter2);
     assert(&result == &iter1);
-    assert(iter1.base().base() == buffer + 2);
+    assert(base(iter1.base()) == buffer + 2);
     assert(iter1.count() == 6);
 
     ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<AssignableFromIter>&);
   }
   {
     std::counted_iterator iter1(AssignableFromIter{buffer}, 8);
     const std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
-    assert(iter1.base().base() == buffer);
+    assert(base(iter1.base()) == buffer);
     assert(iter1.count() == 8);
     std::counted_iterator<AssignableFromIter>& result = (iter1 = iter2);
     assert(&result == &iter1);
-    assert(iter1.base().base() == buffer + 2);
+    assert(base(iter1.base()) == buffer + 2);
     assert(iter1.count() == 6);
 
     ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<AssignableFromIter>&);
   }
 
   {
     std::counted_iterator iter1(InputOrOutputArchetype{buffer}, 8);
     std::counted_iterator iter2(InputOrOutputArchetype{buffer + 2}, 6);

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.iter.pass.cpp

struct InputOrOutputArchetype {
   constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
 };
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
-    assert(iter.base().base() == buffer);
+    assert(base(iter.base()) == buffer);
     assert(iter.count() == 8);
   }
 
   {
     std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
     assert(iter.base() == forward_iterator<int*>{buffer});
     assert(iter.count() == 8);
   }
 
   {
     std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
     assert(iter.base() == contiguous_iterator<int*>{buffer});
     assert(iter.count() == 8);
   }
 
   {
     std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
     assert(iter.base().ptr == buffer);
     assert(iter.count() == 8);
   }
 
   {
     const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
-    assert(iter.base().base() == buffer);
+    assert(base(iter.base()) == buffer);
     assert(iter.count() == 8);
   }
 
   {
     const std::counted_iterator iter(forward_iterator<int*>{buffer}, 7);
     assert(iter.base() == forward_iterator<int*>{buffer});
     assert(iter.count() == 7);
   }
 
   {
     const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 6);
     assert(iter.base() == contiguous_iterator<int*>{buffer});
     assert(iter.count() == 6);
   }
 
   {
     const std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
     assert(iter.base().ptr == buffer);
     assert(iter.count() == 8);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/iterators.common/arrow.pass.cpp

void test() {
   }
 
   // Case 1: http://eel.is/c++draft/iterators.common#common.iter.access-5.1
   {
     auto iter1 = cpp17_input_iterator<int*>(buffer);
     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 
-    assert(commonIter1.operator->().base() == buffer);
-    assert(commonIter2.operator->().base() == buffer);
+    assert(base(commonIter1.operator->()) == buffer);
+    assert(base(commonIter2.operator->()) == buffer);
   }
 
   // Case 1: http://eel.is/c++draft/iterators.common#common.iter.access-5.1
   {
     auto iter1 = forward_iterator<int*>(buffer);
     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 
-    assert(commonIter1.operator->().base() == buffer);
-    assert(commonIter2.operator->().base() == buffer);
+    assert(base(commonIter1.operator->()) == buffer);
+    assert(base(commonIter2.operator->()) == buffer);
   }
 
   // Case 1: http://eel.is/c++draft/iterators.common#common.iter.access-5.1
   {
     auto iter1 = random_access_iterator<int*>(buffer);
     auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
     const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
 
-    assert(commonIter1.operator->().base() == buffer);
-    assert(commonIter2.operator->().base() == buffer);
+    assert(base(commonIter1.operator->()) == buffer);
+    assert(base(commonIter2.operator->()) == buffer);
   }
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/iterators.common/types.h

 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const simple_iterator& i) {return i.it_;}
 
     simple_iterator() = default;
     explicit constexpr simple_iterator(It it) : it_(it) {}
 
     constexpr reference operator*() const {return *it_;}
 
     constexpr simple_iterator& operator++() {++it_; return *this;}
     constexpr simple_iterator operator++(int)
         {simple_iterator tmp(*this); ++(*this); return tmp;}
 };
 
 template <class It>
 class value_iterator
 {
     It it_;
 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const value_iterator& i) {return i.it_;}
 
     value_iterator() = default;
     explicit constexpr value_iterator(It it) : it_(it) {}
 
     constexpr value_type operator*() const {return std::move(*it_);}
 
     constexpr value_iterator& operator++() {++it_; return *this;}
     constexpr value_iterator operator++(int)
         {value_iterator tmp(*this); ++(*this); return tmp;}
 };
 
 template <class It>
 class void_plus_plus_iterator
 {
     It it_;
 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const void_plus_plus_iterator& i) {return i.it_;}
 
     void_plus_plus_iterator() = default;
     explicit constexpr void_plus_plus_iterator(It it) : it_(it) {}
 
     constexpr value_type operator*() const {return std::move(*it_);}
 
     constexpr void_plus_plus_iterator& operator++() {++it_; return *this;}
     constexpr void operator++(int) {++(*this);}
public:
 
     typedef          std::input_iterator_tag                   iterator_category;
     typedef typename std::iterator_traits<It>::value_type      underlying_value_type;
     typedef hold<underlying_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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const value_type_not_move_constructible_iterator& i) {return i.it_;}
 
     value_type_not_move_constructible_iterator() = default;
     explicit constexpr value_type_not_move_constructible_iterator(It it) : it_(it) {}
 
     constexpr underlying_value_type operator*() const {return std::move(*it_);}
 
     constexpr value_type_not_move_constructible_iterator& operator++() {++it_; return *this;}
     constexpr void operator++(int) {++(*this);}
 };
 
 template <class It>
 class comparable_iterator
 {
     It it_;
 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const comparable_iterator& i) {return i.it_;}
 
     comparable_iterator() = default;
     explicit constexpr comparable_iterator(It it) : it_(it) {}
 
     constexpr reference operator*() const {return *it_;}
 
     constexpr comparable_iterator& operator++() {++it_; return *this;}
     constexpr comparable_iterator operator++(int)
         {comparable_iterator tmp(*this); ++(*this); return tmp;}
 
     friend constexpr bool operator==(const comparable_iterator& lhs, const simple_iterator<It>& rhs) {
-      return lhs.base() == rhs.base();
+      return base(lhs) == base(rhs);
     }
     friend constexpr bool operator==(const simple_iterator<It>& lhs, const comparable_iterator& rhs) {
-      return lhs.base() == rhs.base();
+      return base(lhs) == base(rhs);
     }
 
     friend constexpr auto operator-(const comparable_iterator& lhs, const simple_iterator<It>& rhs) {
-      return lhs.base() - rhs.base();
+      return base(lhs) - base(rhs);
     }
     friend constexpr auto operator-(const simple_iterator<It>& lhs, const comparable_iterator& rhs) {
-      return lhs.base() - rhs.base();
+      return base(lhs) - base(rhs);
     }
 };
 
 template<class T>
 struct sentinel_type {
-  T base;
+  T base_;
 
   template<class U>
-  friend constexpr bool operator==(const sentinel_type& lhs, const U& rhs) { return lhs.base == rhs.base(); }
+  friend constexpr bool operator==(const sentinel_type& lhs, const U& rhs) { return lhs.base_ == base(rhs); }
   template<class U>
-  friend constexpr bool operator==(const U& lhs, const sentinel_type& rhs) { return lhs.base() == rhs.base; }
+  friend constexpr bool operator==(const U& lhs, const sentinel_type& rhs) { return base(lhs) == rhs.base_; }
 };
 
 template<class T>
 struct sized_sentinel_type {
-  T base;
+  T base_;
 
   template<class U>
-  friend constexpr bool operator==(const sized_sentinel_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  friend constexpr bool operator==(const sized_sentinel_type& lhs, const U& rhs) { return lhs.base_ - base(rhs); }
   template<class U>
-  friend constexpr bool operator==(const U& lhs, const sized_sentinel_type& rhs) { return lhs.base() - rhs.base; }
+  friend constexpr bool operator==(const U& lhs, const sized_sentinel_type& rhs) { return base(lhs) - rhs.base_; }
   template<class U>
-  friend constexpr auto operator- (const sized_sentinel_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  friend constexpr auto operator- (const sized_sentinel_type& lhs, const U& rhs) { return lhs.base_ - base(rhs); }
   template<class U>
-  friend constexpr auto operator- (const U& lhs, const sized_sentinel_type& rhs) { return lhs.base() - rhs.base; }
+  friend constexpr auto operator- (const U& lhs, const sized_sentinel_type& rhs) { return base(lhs) - rhs.base_; }
 };
 
 template <class It>
 class assignable_iterator
 {
     It it_;
 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const assignable_iterator& i) {return i.it_;}
 
     assignable_iterator() = default;
     explicit constexpr assignable_iterator(It it) : it_(it) {}
 
-    assignable_iterator(const forward_iterator<It>& it) : it_(it.base()) {}
-    assignable_iterator(const sentinel_type<It>& it) : it_(it.base) {}
+    assignable_iterator(const forward_iterator<It>& it) : it_(base(it)) {}
+    assignable_iterator(const sentinel_type<It>& it) : it_(base(it)) {}
 
     constexpr reference operator*() const {return *it_;}
 
     constexpr assignable_iterator& operator++() {++it_; return *this;}
     constexpr assignable_iterator operator++(int)
         {assignable_iterator tmp(*this); ++(*this); return tmp;}
 
     assignable_iterator& operator=(const forward_iterator<It> &other) {
-      it_ = other.base();
+      it_ = base(other);
       return *this;
     }
 
     assignable_iterator& operator=(const sentinel_type<It> &other) {
-      it_ = other.base;
+      it_ = base(other);
       return *this;
     }
 };
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template<class T>
 struct sentinel_throws_on_convert {
-  T base;
+  T base_;
 
   template<class U>
-  friend constexpr bool operator==(const sentinel_throws_on_convert& lhs, const U& rhs) { return lhs.base == rhs.base(); }
+  friend constexpr bool operator==(const sentinel_throws_on_convert& lhs, const U& rhs) { return lhs.base_ == base(rhs); }
   template<class U>
-  friend constexpr bool operator==(const U& lhs, const sentinel_throws_on_convert& rhs) { return lhs.base() == rhs.base; }
+  friend constexpr bool operator==(const U& lhs, const sentinel_throws_on_convert& rhs) { return base(lhs) == rhs.base_; }
 
   operator sentinel_type<int*>() const { throw 42; }
 };
 
 template <class It>
 class maybe_valueless_iterator
 {
     It it_;
 
 public:
     typedef          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;
 
-    constexpr It base() const {return it_;}
+    friend constexpr It base(const maybe_valueless_iterator& i) {return i.it_;}
 
     maybe_valueless_iterator() = default;
     explicit constexpr maybe_valueless_iterator(It it) : it_(it) {}
 
-    maybe_valueless_iterator(const forward_iterator<It>& it) : it_(it.base()) {}
+    maybe_valueless_iterator(const forward_iterator<It>& it) : it_(base(it)) {}
 
     constexpr reference operator*() const {return *it_;}
 
     constexpr maybe_valueless_iterator& operator++() {++it_; return *this;}
     constexpr maybe_valueless_iterator operator++(int)
         {maybe_valueless_iterator tmp(*this); ++(*this); return tmp;}
 
     maybe_valueless_iterator& operator=(const forward_iterator<It> &other) {
-      it_ = other.base();
+      it_ = base(other);
       return *this;
     }
 };
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #endif // TEST_STD_RANGES_ITERATORS_PREDEF_ITERATORS_ITERATORS_COMMON_TYPES_H

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

#endif
         // char, national
         {   // zero
             std::string v = "0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::string v = "-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::string v = "1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::string v = "-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::string v = "-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::string v = "$0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::string v = "$0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
     {
         const my_facet f(1);
         // char, international
         {   // zero
             std::string v = "0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::string v = "-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::string v = "1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::string v = "-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::string v = "-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         const my_facetw f(1);
         // wchar_t, national
         {   // zero
             std::wstring v = L"0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::wstring v = L"-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::wstring v = L"-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::wstring v = L"-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::wstring v = L"-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
         }
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
     {
       // test for err
       const my_facet f(1);
       std::string v = "1.23";

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

#endif
         // char, national
         {   // zero
             std::string v = "0,00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::string v = "-0,01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::string v = "1 234 567,89 ";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::string v = "-1 234 567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::string v = "-1234567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::string v = "0,00 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::string v = "0,00 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::string v = "-0,01 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == 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 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(base(iter) == 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
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-1 234 567,89 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 EUR -";
             std::showbase(ios);
             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(base(iter) == v.data() + 13);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 EUR -";
             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(base(iter) == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
         std::noshowbase(ios);
     }
     {
         const my_facet f(1);
         // char, international
         {   // zero
             std::string v = "0,00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::string v = "-0,01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive
             std::string v = "1 234 567,89 ";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // negative
             std::string v = "-1 234 567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::string v = "-1234567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::string v = "0,00 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::string v = "0,00 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one, showbase
             std::string v = "-0,01 EUR";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::string v = "-0,01 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // positive, showbase
             std::string v = "1 234 567,89 EUR";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
         }
         {   // positive, showbase
             std::string v = "1 234 567,89 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-1 234 567,89 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 Eu-";
             std::showbase(ios);
             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(base(iter) == v.data() + 14);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 Eu-";
             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(base(iter) == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         const my_facetw f(1);
         // wchar_t, national
         {   // zero
             std::wstring v = L"0,00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::wstring v = L"-0,01";
             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(base(iter) == 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 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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::wstring v = L"-1234567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == 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 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(base(iter) == 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
             std::showbase(ios);
             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(base(iter) == 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 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(base(iter) == 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
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"-1 234 567,89 \u20ac");  // EURO SIGN
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
             std::showbase(ios);
             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(base(iter) == v.data() + 13);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
             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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one
             std::wstring v = L"-0,01";
             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(base(iter) == 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 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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // negative
             std::wstring v = L"-1234567,89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
         }
         {   // zero, showbase
             std::wstring v = L"0,00 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // zero, showbase
             std::wstring v = L"0,00 EUR";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 0);
         }
         {   // negative one, showbase
             std::wstring v = L"-0,01 EUR";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -1);
         }
         {   // negative one, showbase
             std::wstring v = L"-0,01 EUR";
             std::showbase(ios);
             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(base(iter) == 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 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(base(iter) == 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");
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == 123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"-1 234 567,89 EUR");
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == -123456789);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
             std::showbase(ios);
             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(base(iter) == v.data() + 14);
             assert(err == std::ios_base::failbit);
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
             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(base(iter) == v.data() + 13);
             assert(err == std::ios_base::goodbit);
             assert(ex == 123456789);
         }
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

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

#endif
         // char, national
         {   // zero
             std::string v = "0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // negative one
             std::string v = "-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // positive
             std::string v = "1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // negative
             std::string v = "-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // negative
             std::string v = "-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // zero, showbase
             std::string v = "$0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // zero, showbase
             std::string v = "$0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // negative one
             std::string v = "-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // positive
             std::string v = "1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // negative
             std::string v = "-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // negative
             std::string v = "-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-1");
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == "-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == "");
         }
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         const my_facetw f(1);
         // wchar_t, national
         {   // zero
             std::wstring v = L"0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // negative one
             std::wstring v = L"-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // negative
             std::wstring v = L"-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             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(base(iter) == 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 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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // negative one
             std::wstring v = L"-0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // negative
             std::wstring v = L"-1234567.89";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"0");
             std::noshowbase(ios);
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-1");
             std::noshowbase(ios);
         }
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
             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(base(iter) == 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";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + v.size());
             assert(err == std::ios_base::eofbit);
             assert(ex == L"-123456789");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             std::showbase(ios);
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
             std::noshowbase(ios);
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             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(base(iter) == v.data() + 1);
             assert(err == std::ios_base::failbit);
             assert(ex == L"");
         }
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
     {
       // test for err
       const my_facet f(1);

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp

 #endif
 {
     const my_facet f(1);
     // char, national
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0.00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0.01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1,234,567.89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1,234,567.89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "$0.00");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$0.01");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "$1,234,567.89");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$1,234,567.89");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$1,234,567.89      ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$      1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "      -$1,234,567.89");
         assert(ios.width() == 0);
     }
 
     // char, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0.00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0.01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1,234,567.89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1,234,567.89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "USD 0.00");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 0.01");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "USD 1,234,567.89");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 1,234,567.89");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 1,234,567.89   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD    1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "   -USD 1,234,567.89");
         assert(ios.width() == 0);
     }
 }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 {
     const my_facetw f(1);
     // wchar_t, national
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0.00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0.01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"1,234,567.89");
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-1,234,567.89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"$0.00");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$0.01");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"$1,234,567.89");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$1,234,567.89");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$1,234,567.89      ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$      1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"      -$1,234,567.89");
         assert(ios.width() == 0);
     }
 
     // wchar_t, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0.00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0.01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"1,234,567.89");
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-1,234,567.89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"USD 0.00");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 0.01");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"USD 1,234,567.89");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 1,234,567.89");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 1,234,567.89   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD    1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"   -USD 1,234,567.89");
         assert(ios.width() == 0);
     }
 }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp

 #endif
 {
     const my_facet f(1);
     // char, national
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0,00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0,01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0,00 \u20ac");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0,01 \u20ac");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1 234 567,89 \u20ac");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89 \u20ac");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89 \u20ac   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89    \u20ac");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "   -1 234 567,89 \u20ac");
         assert(ios.width() == 0);
     }
 
     // char, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0,00");
     }
     {   // negative one
         long double v = -1;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0,01");
     }
     {   // positive
         long double v = 123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1 234 567,89");
     }
     {   // negative
         long double v = -123456789;
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89");
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0,00 EUR");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0,01 EUR");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1 234 567,89 EUR");
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89 EUR");
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89 EUR   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1 234 567,89    EUR");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "   -1 234 567,89 EUR");
         assert(ios.width() == 0);
     }
 }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 {
     const my_facetw f(1);
     // wchar_t, national
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0,00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0,01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"1 234 567,89"));
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89"));
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0,00 \u20ac");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0,01 \u20ac");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"1 234 567,89 \u20ac"));
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89 \u20ac"));
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89 \u20ac     "));
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89      \u20ac"));
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"     -1 234 567,89 \u20ac"));
         assert(ios.width() == 0);
     }
 
     // wchar_t, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         long double v = 0;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0,00");
     }
     {   // negative one
         long double v = -1;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0,01");
     }
     {   // positive
         long double v = 123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"1 234 567,89"));
     }
     {   // negative
         long double v = -123456789;
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89"));
     }
     {   // zero, showbase
         long double v = 0;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0,00 EUR");
     }
     {   // negative one, showbase
         long double v = -1;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0,01 EUR");
     }
     {   // positive, showbase
         long double v = 123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"1 234 567,89 EUR"));
     }
     {   // negative, showbase
         long double v = -123456789;
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89 EUR"));
     }
     {   // negative, showbase, left
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89 EUR   "));
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"-1 234 567,89    EUR"));
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         long double v = -123456789;
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == convert_thousands_sep(L"   -1 234 567,89 EUR"));
         assert(ios.width() == 0);
     }
 }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp

 #endif
 {
     const my_facet f(1);
     // char, national
     {   // zero
         std::string v = "0";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0.00");
     }
     {   // negative one
         std::string v = "-1";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0.01");
     }
     {   // positive
         std::string v = "123456789";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1,234,567.89");
     }
     {   // negative
         std::string v = "-123456789";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1,234,567.89");
     }
     {   // zero, showbase
         std::string v = "0";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "$0.00");
     }
     {   // negative one, showbase
         std::string v = "-1";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$0.01");
     }
     {   // positive, showbase
         std::string v = "123456789";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "$1,234,567.89");
     }
     {   // negative, showbase
         std::string v = "-123456789";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$1,234,567.89");
     }
     {   // negative, showbase, left
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$1,234,567.89      ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-$      1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), false, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "      -$1,234,567.89");
         assert(ios.width() == 0);
     }
 
     // char, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         std::string v = "0";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0.00");
     }
     {   // negative one
         std::string v = "-1";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-0.01");
     }
     {   // positive
         std::string v = "123456789";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1,234,567.89");
     }
     {   // negative
         std::string v = "-123456789";
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1,234,567.89");
     }
     {   // zero, showbase
         std::string v = "0";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "USD 0.00");
     }
     {   // negative one, showbase
         std::string v = "-1";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 0.01");
     }
     {   // positive, showbase
         std::string v = "123456789";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "USD 1,234,567.89");
     }
     {   // negative, showbase
         std::string v = "-123456789";
         std::showbase(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 1,234,567.89");
     }
     {   // negative, showbase, left
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD 1,234,567.89   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-USD    1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         std::string v = "-123456789";
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         char str[100];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), true, ios, ' ', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "   -USD 1,234,567.89");
         assert(ios.width() == 0);
     }
 }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 {
     const my_facetw f(1);
     // wchar_t, national
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         std::wstring v = L"0";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0.00");
     }
     {   // negative one
         std::wstring v = L"-1";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0.01");
     }
     {   // positive
         std::wstring v = L"123456789";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"1,234,567.89");
     }
     {   // negative
         std::wstring v = L"-123456789";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-1,234,567.89");
     }
     {   // zero, showbase
         std::wstring v = L"0";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"$0.00");
     }
     {   // negative one, showbase
         std::wstring v = L"-1";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$0.01");
     }
     {   // positive, showbase
         std::wstring v = L"123456789";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"$1,234,567.89");
     }
     {   // negative, showbase
         std::wstring v = L"-123456789";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$1,234,567.89");
     }
     {   // negative, showbase, left
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$1,234,567.89      ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-$      1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), false, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"      -$1,234,567.89");
         assert(ios.width() == 0);
     }
 
     // wchar_t, international
     std::noshowbase(ios);
     ios.unsetf(std::ios_base::adjustfield);
     {   // zero
         std::wstring v = L"0";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"0.00");
     }
     {   // negative one
         std::wstring v = L"-1";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-0.01");
     }
     {   // positive
         std::wstring v = L"123456789";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"1,234,567.89");
     }
     {   // negative
         std::wstring v = L"-123456789";
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-1,234,567.89");
     }
     {   // zero, showbase
         std::wstring v = L"0";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"USD 0.00");
     }
     {   // negative one, showbase
         std::wstring v = L"-1";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 0.01");
     }
     {   // positive, showbase
         std::wstring v = L"123456789";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"USD 1,234,567.89");
     }
     {   // negative, showbase
         std::wstring v = L"-123456789";
         std::showbase(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, '*', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 1,234,567.89");
     }
     {   // negative, showbase, left
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::left(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD 1,234,567.89   ");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, internal
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::internal(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"-USD    1,234,567.89");
         assert(ios.width() == 0);
     }
     {   // negative, showbase, right
         std::wstring v = L"-123456789";
         std::showbase(ios);
         ios.width(20);
         std::right(ios);
         wchar_t str[100];
         cpp17_output_iterator<wchar_t*> iter = f.put(cpp17_output_iterator<wchar_t*>(str), true, ios, ' ', v);
-        std::wstring ex(str, iter.base());
+        std::wstring ex(str, base(iter));
         assert(ex == L"   -USD 1,234,567.89");
         assert(ios.width() == 0);
     }
 }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp

 {
     const my_facet f(1);
     {
         std::ios ios(0);
         {
             bool v = false;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "0");
         }
         {
             bool v = true;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "1");
         }
     }
     {
         std::ios ios(0);
         std::boolalpha(ios);
         {
             bool v = false;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "false");
         }
         {
             bool v = true;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "true");
         }
     }
     {
         std::ios ios(0);
         std::boolalpha(ios);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         {
             bool v = false;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "no");
         }
         {
             bool v = true;
             char str[50];
             cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-            std::string ex(str, iter.base());
+            std::string ex(str, base(iter));
             assert(ex == "yes");
         }
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp

 int main(int, char**)
 {
     const my_facet f(1);
     {
         std::ios ios(0);
         long v = 0;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0");
     }
     {
         std::ios ios(0);
         long v = 1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1");
     }
     {
         std::ios ios(0);
         long v = -1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1");
     }
     {
         std::ios ios(0);
         long v = -1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1000");
     }
     {
         std::ios ios(0);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::showpos(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+1000");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1750");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         std::showbase(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01750");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E_8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7*****");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "**0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f**");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x**7f_fff_ff_f");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long v = 1000;
         std::right(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "***+1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long v = 1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+1_00_0***");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long v = 1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+***1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long v = -1000;
         std::right(ios);
         std::showpos(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "***-1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long v = -1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1_00_0***");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long v = -1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp

 int main(int, char**)
 {
     const my_facet f(1);
     {
         std::ios ios(0);
         long long v = 0;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0");
     }
     {
         std::ios ios(0);
         long long v = 1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1");
     }
     {
         std::ios ios(0);
         long long v = -1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1");
     }
     {
         std::ios ios(0);
         long long v = -1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1000");
     }
     {
         std::ios ios(0);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::showpos(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+1000");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1750");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         std::showbase(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01750");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E_8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7*****");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "**0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f**");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x**7f_fff_ff_f");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long long v = 1000;
         std::right(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "***+1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long long v = 1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+1_00_0***");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         long long v = 1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "+***1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long long v = -1000;
         std::right(ios);
         std::showpos(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "***-1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long long v = -1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-1_00_0***");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         long long v = -1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp

 int main(int, char**)
 {
     const my_facet f(1);
     {
         std::ios ios(0);
         void* v = 0;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         char expected_str[32] = {};
         // num_put::put uses %p for pointer types, but the exact format of %p is
         // implementation defined behavior for the C library. Compare output to
         // snprintf for portability.
         int rc = snprintf(expected_str, sizeof(expected_str), "%p", v);
         assert(rc > 0);
         assert(ex == expected_str);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp

 int main(int, char**)
 {
     const my_facet f(1);
     {
         std::ios ios(0);
         unsigned long v = 0;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0");
     }
     {
         std::ios ios(0);
         unsigned long v = 1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1");
     }
     {
         std::ios ios(0);
         unsigned long v = static_cast<unsigned long>(-1);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == (sizeof(unsigned long) == 4 ? "4294967295" : "18446744073709551615"));
     }
     {
         std::ios ios(0);
         unsigned long v = static_cast<unsigned long>(-1000);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == (sizeof(unsigned long) == 4 ? "4294966296" : "18446744073709550616"));
     }
     {
         std::ios ios(0);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::showpos(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1750");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         std::showbase(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01750");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         unsigned long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E_8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         unsigned long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         unsigned long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         unsigned long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         unsigned long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         unsigned long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7*****");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         unsigned long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         unsigned long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "**0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         unsigned long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f**");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         unsigned long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x**7f_fff_ff_f");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long v = 1000;
         std::right(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "****1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long v = 1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1_00_0****");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long v = 1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "****1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long v = static_cast<unsigned long>(-1000);
         std::right(ios);
         std::showpos(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
                                                  : "18_446_744_073_709_550_61_6"));
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long v = static_cast<unsigned long>(-1000);
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
                                                  : "18_446_744_073_709_550_61_6"));
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long v = static_cast<unsigned long>(-1000);
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == (sizeof(unsigned long) == 4 ? "4_294_966_29_6"
                                                  : "18_446_744_073_709_550_61_6"));
         assert(ios.width() == 0);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp

 int main(int, char**)
 {
     const my_facet f(1);
     {
         std::ios ios(0);
         unsigned long long v = 0;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0");
     }
     {
         std::ios ios(0);
         unsigned long long v = 1;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1");
     }
     {
         std::ios ios(0);
         unsigned long long v = static_cast<unsigned long long>(-1);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18446744073709551615");
     }
     {
         std::ios ios(0);
         unsigned long long v = static_cast<unsigned long long>(-1000);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18446744073709550616");
     }
     {
         std::ios ios(0);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::showpos(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1000");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1750");
     }
     {
         std::ios ios(0);
         std::oct(ios);
         std::showbase(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01750");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x3e8");
     }
     {
         std::ios ios(0);
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::uppercase(ios);
         unsigned long long v = 1000;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0X3E_8");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         unsigned long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         unsigned long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         unsigned long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         unsigned long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         unsigned long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0_123_46_7*****");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::oct(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         unsigned long long v = 0123467;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "*****0_123_46_7");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::right(ios);
         ios.width(15);
         unsigned long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "**0x7f_fff_ff_f");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::left(ios);
         ios.width(15);
         unsigned long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x7f_fff_ff_f**");
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::hex(ios);
         std::showbase(ios);
         std::internal(ios);
         ios.width(15);
         unsigned long long v = 2147483647;
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "0x**7f_fff_ff_f");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long long v = 1000;
         std::right(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "****1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long long v = 1000;
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "1_00_0****");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         std::showpos(ios);
         unsigned long long v = 1000;
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "****1_00_0");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long long v = static_cast<unsigned long long>(-1000);
         std::right(ios);
         std::showpos(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18_446_744_073_709_550_61_6");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long long v = static_cast<unsigned long long>(-1000);
         std::left(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18_446_744_073_709_550_61_6");
         assert(ios.width() == 0);
     }
     {
         std::ios ios(0);
         ios.imbue(std::locale(std::locale::classic(), new my_numpunct));
         unsigned long long v = static_cast<unsigned long long>(-1000);
         std::internal(ios);
         ios.width(10);
         char str[50];
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', v);
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18_446_744_073_709_550_61_6");
         assert(ios.width() == 0);
     }
 
   return 0;
 }

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

int main(int, char**)
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(b == true);
     }
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(b == false);
     }
     {
         const char str[] = "12";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(b == true);
     }
     {
         const char str[] = "*12";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+0);
         assert(err == ios.failbit);
         assert(b == false);
     }
     std::boolalpha(ios);
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+0);
         assert(err == ios.failbit);
         assert(b == false);
     }
     {
         const char str[] = "true";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(b == true);
     }
     {
         const char str[] = "false";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == 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;
         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(base(iter) == str+1);
         assert(err == ios.eofbit);
         assert(b == true);
     }
     {
         const char str[] = "abc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+2);
         assert(err == ios.failbit);
         assert(b == false);
     }
     {
         const char str[] = "acc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == 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;
         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(base(iter) == str+1);
         assert(err == ios.eofbit);
         assert(b == true);
     }
     {
         const char str[] = "ab";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+2);
         assert(err == ios.eofbit);
         assert(b == false);
     }
     {
         const char str[] = "abc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == str+2);
         assert(err == ios.goodbit);
         assert(b == false);
     }
     {
         const char str[] = "ac";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
         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(base(iter) == 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

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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -123);
     }
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123.5);
     }
     {
         const char str[] = "125e-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 125e-1);
     }
     {
         const char str[] = "0x125p-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == hexfloat<double>(0x125, 0, -1));
     }
     {
         const char str[] = "inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "-inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "-INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "nan";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(std::isnan(v));
     }
     {
         const char str[] = "NAN";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == str+3);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         // See PR11871
         v = -1;
         const char str[] = "2-";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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

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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -123);
     }
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123.5);
     }
     {
         const char str[] = "125e-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 125e-1);
     }
     {
         const char str[] = "0x125p-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == hexfloat<float>(0x125, 0, -1));
     }
     {
         const char str[] = "inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "-inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "-INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "nan";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(std::isnan(v));
     }
     {
         const char str[] = "NAN";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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

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;
         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(base(iter) == 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;
         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(base(iter) == str+4);
         assert(err == ios.goodbit);
         assert(v == -123);
     }
     {
         const char str[] = "123";
         std::oct(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+3);
         assert(err == ios.goodbit);
         assert(v == 83);
     }
     {
         const char str[] = "123";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+3);
         assert(err == ios.goodbit);
         assert(v == 291);
     }
     {
         const char str[] = "0x123";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == str+1);
         assert(err == ios.goodbit);
         assert(v == 2);
     }
     std::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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         v = -1;
         const char str[] = "+1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "+1_";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "+_1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "_+1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "+1__";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "+_1_";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "_+1_";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "+__1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "_+_1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 1);
     }
     {
         v = -1;
         const char str[] = "__+1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 12);
     }
     {
         v = -1;
         const char str[] = "+12_";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == 12);
     }
     {
         v = -1;
         const char str[] = "+_12";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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

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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -123);
     }
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123.5);
     }
     {
         const char str[] = "125e-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 125e-1);
     }
     {
         const char str[] = "0x125p-1";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == hexfloat<long double>(0x125, 0, -1));
     }
     {
         const char str[] = "inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "-inf";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "-INF";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -INFINITY);
     }
     {
         const char str[] = "nan";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(std::isnan(v));
     }
     {
         const char str[] = "NAN";
         std::hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.failbit);
         assert(v == INFINITY);
     }
     {
         const char str[] = "304888344611713860501504000000";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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

int main(int, char**)
     long long v = -1;
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0);
     }
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     {
         const char str[] = "-1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == -1);
     }
     std::hex(ios);
     {
         const char str[] = "0x7FFFFFFFFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0x7FFFFFFFFFFFFFFFLL);
     }
     {
         const char str[] = "-0x8000000000000000";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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

int main(int, char**)
     {
         const char str[] = "0x0";
         std::ios_base::iostate err = ios.goodbit;
         void* p;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(p == 0);
     }
     {
         const char str[] = "0x73";
         std::ios_base::iostate err = ios.goodbit;
         void* p;
         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(base(iter) == 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

int main(int, char**)
     unsigned int v = static_cast<unsigned int>(-1);
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0);
     }
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     std::hex(ios);
     {
         const char str[] = "0xFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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

int main(int, char**)
     unsigned long v = static_cast<unsigned long>(-1);
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0);
     }
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     std::hex(ios);
     {
         const char str[] = "0xFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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

int main(int, char**)
     unsigned long long v = static_cast<unsigned long long>(-1);
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0);
     }
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     std::hex(ios);
     {
         const char str[] = "0xFFFFFFFFFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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

int main(int, char**)
     unsigned short v = static_cast<unsigned short>(-1);
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 0);
     }
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 1);
     }
     std::hex(ios);
     {
         const char str[] = "0xFFFF";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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

void test_neg_one() {
     T v = static_cast<T>(42);
     {
         const char str[] = "-1";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == T(-1));
     }
     v = 42;
     {
         const char str[] = "-";
         std::ios_base::iostate err = ios.goodbit;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == 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;
         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(base(iter) == str+size);
         assert(err == ios.failbit);
         assert(v == T(-1));
     }
 }
 
 int main(int, char**)
 {
     test_neg_one<long>();

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "5/5/5";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_date(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 4);
         assert(t.tm_mday == 5);
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const wchar_t in[] = L"5/5/5";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_date(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
+        assert(base(i) == in+sizeof(in)/sizeof(in[0])-1);
         assert(t.tm_mon == 4);
         assert(t.tm_mday == 5);
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "2009 May 9, 10:27pm";
         const char fmt[] = "%Y %b %d, %I:%M%p";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 109);
         assert(t.tm_mon == 4);
         assert(t.tm_mday == 9);
         assert(t.tm_hour == 22);
         assert(t.tm_min == 27);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "10:27PM May 9, 2009";
         const char fmt[] = "%I:%M%p %b %d, %Y";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, fmt, fmt+sizeof(fmt)-1);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 109);
         assert(t.tm_mon == 4);
         assert(t.tm_mday == 9);
         assert(t.tm_hour == 22);
         assert(t.tm_min == 27);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "Jan";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Feb";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Mar";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Apr";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "May";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Jun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Jul";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Aug";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 7);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Sep";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 8);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Oct";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 9);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Nov";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Dec";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "January";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "February";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "March";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "April";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "May";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "June";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "July";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_mon == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "August";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_mon == 7);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "September";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+9);
+        assert(base(i) == in+9);
         assert(t.tm_mon == 8);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "October";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_mon == 9);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "November";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "December";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Decemper";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const wchar_t in[] = L"Jan";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Feb";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Mar";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Apr";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"May";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Jun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Jul";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Aug";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 7);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Sep";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 8);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Oct";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 9);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Nov";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Dec";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"January";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"February";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"March";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"April";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"May";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_mon == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"June";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"July";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_mon == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"August";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_mon == 7);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"September";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+9);
+        assert(base(i) == in+9);
         assert(t.tm_mon == 8);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"October";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_mon == 9);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"November";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"December";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_mon == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Decemper";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_monthname(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "mon";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'a');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "wednesdaY";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'A');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "June";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'b');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Jul";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'B');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Thu Jun  6 09:49:10 2009";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'c');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_wday == 4);
         assert(t.tm_mon == 5);
         assert(t.tm_mday == 6);
         assert(t.tm_hour == 9);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "11";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'd');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mday == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "2/1/1";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'D');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 1);
         assert(t.tm_mday == 1);
         assert(t.tm_year == 101);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "11";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'e');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mday == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "June";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'h');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "19";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'H');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 19);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "12";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'm');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 11);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "59";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'M');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_min == 59);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "\t\n ";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'n');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "09:49:10 PM";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 21);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "09:49:10 AM";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 9);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "12:49:10 AM";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "12:49:10 PM";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'r');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 12);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "09:49";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'R');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 9);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'S');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 0);
         assert(t.tm_sec == 60);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "\t\n ";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 't');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "21:49:10";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'T');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 21);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "3";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'w');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "06/06/09";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'x');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_mon == 5);
         assert(t.tm_mday == 6);
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "21:49:10";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'X');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 21);
         assert(t.tm_min == 49);
         assert(t.tm_sec == 10);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "68";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'y');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 168);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "68";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, 'Y');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == -1832);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "%";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get(I(in), I(in+sizeof(in)-1), ios, err, &t, '%');
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "0:0:0";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 0);
         assert(t.tm_sec == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "23:59:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_hour == 23);
         assert(t.tm_min == 59);
         assert(t.tm_sec == 60);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "24:59:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+2);
+        assert(base(i) == in+2);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 0);
         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
     {
         const char in[] = "23:60:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
     {
         const char in[] = "23:59:61";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const char in[] = "2:43:221";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_hour == 2);
         assert(t.tm_min == 43);
         assert(t.tm_sec == 22);
         assert(err == std::ios_base::goodbit);
     }
     {
         const char in[] = "2.43:221";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+1);
+        assert(base(i) == in+1);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const wchar_t in[] = L"0:0:0";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
+        assert(base(i) == in+sizeof(in)/sizeof(in[0])-1);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 0);
         assert(t.tm_sec == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"23:59:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)/sizeof(in[0])-1);
+        assert(base(i) == in+sizeof(in)/sizeof(in[0])-1);
         assert(t.tm_hour == 23);
         assert(t.tm_min == 59);
         assert(t.tm_sec == 60);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"24:59:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+2);
+        assert(base(i) == in+2);
         assert(t.tm_hour == 0);
         assert(t.tm_min == 0);
         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
     {
         const wchar_t in[] = L"23:60:60";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+5);
+        assert(base(i) == in+5);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
     {
         const wchar_t in[] = L"23:59:61";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const wchar_t in[] = L"2:43:221";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_hour == 2);
         assert(t.tm_min == 43);
         assert(t.tm_sec == 22);
         assert(err == std::ios_base::goodbit);
     }
     {
         const wchar_t in[] = L"2.43:221";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_time(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+1);
+        assert(base(i) == in+1);
 //         assert(t.tm_hour == 0);
 //         assert(t.tm_min == 0);
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "Sun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Suny";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::goodbit);
     }
     {
         const char in[] = "Sund";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_wday == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const char in[] = "sun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "sunday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Mon";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Mony";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::goodbit);
     }
     {
         const char in[] = "Mond";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_wday == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const char in[] = "mon";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "monday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Tue";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Tuesday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_wday == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Wed";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Wednesday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+9);
+        assert(base(i) == in+9);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Thu";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Thursday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_wday == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Fri";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Friday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Sat";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "Saturday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const wchar_t in[] = L"Sun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Suny";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::goodbit);
     }
     {
         const wchar_t in[] = L"Sund";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_wday == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const wchar_t in[] = L"sun";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"sunday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Mon";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Mony";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::goodbit);
     }
     {
         const wchar_t in[] = L"Mond";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+4);
+        assert(base(i) == in+4);
         assert(t.tm_wday == 0);
         assert(err == (std::ios_base::failbit | std::ios_base::eofbit));
     }
     {
         const wchar_t in[] = L"mon";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"monday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Tue";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Tuesday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+7);
+        assert(base(i) == in+7);
         assert(t.tm_wday == 2);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Wed";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Wednesday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+9);
+        assert(base(i) == in+9);
         assert(t.tm_wday == 3);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Thu";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Thursday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_wday == 4);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Fri";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Friday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+6);
+        assert(base(i) == in+6);
         assert(t.tm_wday == 5);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Sat";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+3);
+        assert(base(i) == in+3);
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
     {
         const wchar_t in[] = L"Saturday";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_weekday(I(in), I(in+sizeof(in)/sizeof(in[0])-1), ios, err, &t);
-        assert(i.base() == in+8);
+        assert(base(i) == in+8);
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
 
   return 0;
 }

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

int main(int, char**)
     std::ios ios(0);
     std::ios_base::iostate err;
     std::tm t;
     {
         const char in[] = "0";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 100);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "00";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 100);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "1";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 101);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "68";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 168);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "69";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 69);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "99";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 99);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "100";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == -1800);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "1900";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 0);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "1968";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 68);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "2000";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-1);
+        assert(base(i) == in+sizeof(in)-1);
         assert(t.tm_year == 100);
         assert(err == std::ios_base::eofbit);
     }
     {
         const char in[] = "2999c";
         err = std::ios_base::goodbit;
         t = std::tm();
         I i = f.get_year(I(in), I(in+sizeof(in)-1), ios, err, &t);
-        assert(i.base() == in+sizeof(in)-2);
+        assert(base(i) == in+sizeof(in)-2);
         assert(t.tm_year == 1099);
         assert(err == std::ios_base::goodbit);
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp

int main(int, char**)
     t.tm_yday = -1;
     t.tm_isdst = 1;
     std::ios ios(0);
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
         std::string pat("Today is %A which is abbreviated %a.");
         cpp17_output_iterator<char*> iter =
             f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Today is Saturday which is abbreviated Sat.");
     }
     {
         const my_facet f(LOCALE_fr_FR_UTF_8, 1);
         std::string pat("Today is %A which is abbreviated '%a'.");
         cpp17_output_iterator<char*> iter =
             f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert((ex == "Today is Samedi which is abbreviated 'Sam'.")||
                (ex == "Today is samedi which is abbreviated 'sam'." )||
                (ex == "Today is samedi which is abbreviated 'sam.'."));
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp

int main(int, char**)
     t.tm_wday = 6;
     t.tm_yday = -1;
     t.tm_isdst = 1;
     std::ios ios(0);
     {
         std::string pat("Today is %A which is abbreviated %a.");
         cpp17_output_iterator<char*> iter =
             f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Today is Saturday which is abbreviated Sat.");
     }
     {
         std::string pat("The number of the month is %Om.");
         cpp17_output_iterator<char*> iter =
             f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, pat.data(), pat.data() + pat.size());
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "The number of the month is 05.");
     }
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

int main(int, char**)
     t.tm_mon = 4;
     t.tm_year = 109;
     t.tm_wday = 6;
     t.tm_yday = 121;
     t.tm_isdst = 1;
     std::ios ios(0);
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'A');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Saturday");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'a');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Sat");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'B');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "May");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'b');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "May");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'C');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "20");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'c');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Sat May  2 13:03:06 2009");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'D');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "05/02/09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'd');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "02");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'c', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "Sat May  2 13:03:06 2009");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'C', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "20");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'x', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "05/02/09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'X', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13:03:06");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'y', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'Y', 'E');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "2009");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'd', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "02");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'e', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == " 2");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'H', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'I', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'm', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "05");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'M', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "03");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'S', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "06");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'u', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "6");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'U', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "17");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'V', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'w', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "6");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'W', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "17");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'y', 'O');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'e');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == " 2");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'F');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "2009-05-02");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'G');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "2009");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'g');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'H');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'h');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "May");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'I');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'j');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "122");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'M');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "03");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'm');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "05");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'n');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "\n");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'p');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "PM");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'R');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13:03");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'r');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "01:03:06 PM");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'S');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "06");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'T');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13:03:06");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 't');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "\t");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'U');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "17");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'u');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "6");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'V');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "18");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'W');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "17");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'w');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "6");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'X');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "13:03:06");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'x');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "05/02/09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'Y');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "2009");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'y');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "09");
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'Z');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
 //        assert(ex == "EDT");  depends on time zone
     }
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, 'z');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
 //        assert(ex == "-0400");  depends on time zone
     }
 #ifndef _WIN32
     // The Windows strftime() doesn't support the "%+" format. Depending on CRT
     // configuration of the invalid parameter handler, this can abort the process.
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, '+');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
 //        assert(ex == "Sat May  2 13:03:06 EDT 2009");  depends on time zone
     }
 #endif
     {
         cpp17_output_iterator<char*> iter = f.put(cpp17_output_iterator<char*>(str), ios, '*', &t, '%');
-        std::string ex(str, iter.base());
+        std::string ex(str, base(iter));
         assert(ex == "%");
     }
 
   return 0;
 }

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

 static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginAndRBegin&>);
 static_assert( std::is_invocable_v<RangeCRBeginT, MemberBeginAndRBegin&>);
 static_assert( std::same_as<std::invoke_result_t<RangeRBeginT, MemberBeginAndRBegin&>, int*>);
 static_assert( std::same_as<std::invoke_result_t<RangeCRBeginT, MemberBeginAndRBegin&>, int*>);
 
 constexpr bool testBeginEnd() {
   MemberBeginEnd a{};
   const MemberBeginEnd aa{};
-  assert(std::ranges::rbegin(a).base().base() == &a.e);
-  assert(std::ranges::crbegin(a).base().base() == &a.ce);
-  assert(std::ranges::rbegin(aa).base().base() == &aa.ce);
-  assert(std::ranges::crbegin(aa).base().base() == &aa.ce);
+  assert(base(std::ranges::rbegin(a).base()) == &a.e);
+  assert(base(std::ranges::crbegin(a).base()) == &a.ce);
+  assert(base(std::ranges::rbegin(aa).base()) == &aa.ce);
+  assert(base(std::ranges::crbegin(aa).base()) == &aa.ce);
 
   FunctionBeginEnd b{};
   const FunctionBeginEnd bb{};
-  assert(std::ranges::rbegin(b).base().base() == &b.e);
-  assert(std::ranges::crbegin(b).base().base() == &b.ce);
-  assert(std::ranges::rbegin(bb).base().base() == &bb.ce);
-  assert(std::ranges::crbegin(bb).base().base() == &bb.ce);
+  assert(base(std::ranges::rbegin(b).base()) == &b.e);
+  assert(base(std::ranges::crbegin(b).base()) == &b.ce);
+  assert(base(std::ranges::rbegin(bb).base()) == &bb.ce);
+  assert(base(std::ranges::crbegin(bb).base()) == &bb.ce);
 
   MemberBeginFunctionEnd c{};
   const MemberBeginFunctionEnd cc{};
-  assert(std::ranges::rbegin(c).base().base() == &c.e);
-  assert(std::ranges::crbegin(c).base().base() == &c.ce);
-  assert(std::ranges::rbegin(cc).base().base() == &cc.ce);
-  assert(std::ranges::crbegin(cc).base().base() == &cc.ce);
+  assert(base(std::ranges::rbegin(c).base()) == &c.e);
+  assert(base(std::ranges::crbegin(c).base()) == &c.ce);
+  assert(base(std::ranges::rbegin(cc).base()) == &cc.ce);
+  assert(base(std::ranges::crbegin(cc).base()) == &cc.ce);
 
   FunctionBeginMemberEnd d{};
   const FunctionBeginMemberEnd dd{};
-  assert(std::ranges::rbegin(d).base().base() == &d.e);
-  assert(std::ranges::crbegin(d).base().base() == &d.ce);
-  assert(std::ranges::rbegin(dd).base().base() == &dd.ce);
-  assert(std::ranges::crbegin(dd).base().base() == &dd.ce);
+  assert(base(std::ranges::rbegin(d).base()) == &d.e);
+  assert(base(std::ranges::crbegin(d).base()) == &d.ce);
+  assert(base(std::ranges::rbegin(dd).base()) == &dd.ce);
+  assert(base(std::ranges::crbegin(dd).base()) == &dd.ce);
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::rbegin(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::crbegin(std::declval<int (&)[10]>()));
 

libcxx/test/std/ranges/range.access/rend.pass.cpp

 static_assert( std::is_invocable_v<RangeREndT, MemberBeginAndRBegin&>);
 static_assert( std::is_invocable_v<RangeCREndT, MemberBeginAndRBegin&>);
 static_assert( std::same_as<std::invoke_result_t<RangeREndT, MemberBeginAndRBegin&>, int*>);
 static_assert( std::same_as<std::invoke_result_t<RangeCREndT, MemberBeginAndRBegin&>, int*>);
 
 constexpr bool testBeginEnd() {
   MemberBeginEnd a{};
   const MemberBeginEnd aa{};
-  assert(std::ranges::rend(a).base().base() == &a.b);
-  assert(std::ranges::crend(a).base().base() == &a.cb);
-  assert(std::ranges::rend(aa).base().base() == &aa.cb);
-  assert(std::ranges::crend(aa).base().base() == &aa.cb);
+  assert(base(std::ranges::rend(a).base()) == &a.b);
+  assert(base(std::ranges::crend(a).base()) == &a.cb);
+  assert(base(std::ranges::rend(aa).base()) == &aa.cb);
+  assert(base(std::ranges::crend(aa).base()) == &aa.cb);
 
   FunctionBeginEnd b{};
   const FunctionBeginEnd bb{};
-  assert(std::ranges::rend(b).base().base() == &b.b);
-  assert(std::ranges::crend(b).base().base() == &b.cb);
-  assert(std::ranges::rend(bb).base().base() == &bb.cb);
-  assert(std::ranges::crend(bb).base().base() == &bb.cb);
+  assert(base(std::ranges::rend(b).base()) == &b.b);
+  assert(base(std::ranges::crend(b).base()) == &b.cb);
+  assert(base(std::ranges::rend(bb).base()) == &bb.cb);
+  assert(base(std::ranges::crend(bb).base()) == &bb.cb);
 
   MemberBeginFunctionEnd c{};
   const MemberBeginFunctionEnd cc{};
-  assert(std::ranges::rend(c).base().base() == &c.b);
-  assert(std::ranges::crend(c).base().base() == &c.cb);
-  assert(std::ranges::rend(cc).base().base() == &cc.cb);
-  assert(std::ranges::crend(cc).base().base() == &cc.cb);
+  assert(base(std::ranges::rend(c).base()) == &c.b);
+  assert(base(std::ranges::crend(c).base()) == &c.cb);
+  assert(base(std::ranges::rend(cc).base()) == &cc.cb);
+  assert(base(std::ranges::crend(cc).base()) == &cc.cb);
 
   FunctionBeginMemberEnd d{};
   const FunctionBeginMemberEnd dd{};
-  assert(std::ranges::rend(d).base().base() == &d.b);
-  assert(std::ranges::crend(d).base().base() == &d.cb);
-  assert(std::ranges::rend(dd).base().base() == &dd.cb);
-  assert(std::ranges::crend(dd).base().base() == &dd.cb);
+  assert(base(std::ranges::rend(d).base()) == &d.b);
+  assert(base(std::ranges::crend(d).base()) == &d.cb);
+  assert(base(std::ranges::rend(dd).base()) == &dd.cb);
+  assert(base(std::ranges::crend(dd).base()) == &dd.cb);
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::rend(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::crend(std::declval<int (&)[10]>()));
 

libcxx/test/std/ranges/range.adaptors/range.all/range.ref.view/range.ref.view.pass.cpp

 
 struct ForwardRange {
   constexpr forward_iterator<int*> begin() const { return forward_iterator<int*>(globalBuff); }
   constexpr forward_iterator<int*> end() const { return forward_iterator<int*>(globalBuff + 8); }
 };
 
 struct Cpp17InputRange {
   struct sentinel {
-    friend constexpr bool operator==(sentinel, cpp17_input_iterator<int*> iter) { return iter.base() == globalBuff + 8; }
+    friend constexpr bool operator==(sentinel, cpp17_input_iterator<int*> iter) { return base(iter) == globalBuff + 8; }
     friend constexpr std::ptrdiff_t operator-(sentinel, cpp17_input_iterator<int*>) { return -8; }
     friend constexpr std::ptrdiff_t operator-(cpp17_input_iterator<int*>, sentinel) { return 8; }
   };
 
   constexpr cpp17_input_iterator<int*> begin() const {
     return cpp17_input_iterator<int*>(globalBuff);
   }
   constexpr sentinel end() const { return {}; }
 };
 
 struct Cpp20InputRange {
   struct sentinel {
-    friend constexpr bool operator==(sentinel, const cpp20_input_iterator<int*> &iter) { return iter.base() == globalBuff + 8; }
+    friend constexpr bool operator==(sentinel, const cpp20_input_iterator<int*> &iter) { return base(iter) == globalBuff + 8; }
     friend constexpr std::ptrdiff_t operator-(sentinel, const cpp20_input_iterator<int*>&) { return -8; }
   };
 
   constexpr cpp20_input_iterator<int*> begin() const {
     return cpp20_input_iterator<int*>(globalBuff);
   }
   constexpr sentinel end() const { return {}; }
 };
constexpr bool test() {
   {
     // ref_view::begin
     Range range1;
     std::ranges::ref_view<Range> view1 = range1;
     assert(view1.begin() == globalBuff);
 
     ForwardRange range2;
     std::ranges::ref_view<ForwardRange> view2 = range2;
-    assert(view2.begin().base() == globalBuff);
+    assert(base(view2.begin()) == globalBuff);
 
     Cpp17InputRange range3;
     std::ranges::ref_view<Cpp17InputRange> view3 = range3;
-    assert(view3.begin().base() == globalBuff);
+    assert(base(view3.begin()) == globalBuff);
 
     Cpp20InputRange range4;
     std::ranges::ref_view<Cpp20InputRange> view4 = range4;
-    assert(view4.begin().base() == globalBuff);
+    assert(base(view4.begin()) == globalBuff);
   }
 
   {
     // ref_view::end
     Range range1;
     std::ranges::ref_view<Range> view1 = range1;
     assert(view1.end() == globalBuff + 8);
 
     ForwardRange range2;
     std::ranges::ref_view<ForwardRange> view2 = range2;
-    assert(view2.end().base() == globalBuff + 8);
+    assert(base(view2.end()) == globalBuff + 8);
 
     Cpp17InputRange range3;
     std::ranges::ref_view<Cpp17InputRange> view3 = range3;
     assert(view3.end() == cpp17_input_iterator(globalBuff + 8));
 
     Cpp20InputRange range4;
     std::ranges::ref_view<Cpp20InputRange> view4 = range4;
     assert(view4.end() == cpp20_input_iterator(globalBuff + 8));

libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp

 
 constexpr bool test() {
   int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     SizedRandomAccessView view{buf, buf + 8};
     std::ranges::common_view<SizedRandomAccessView> common(view);
     std::same_as<RandomAccessIter> auto end = common.end(); // Note this should NOT be the sentinel type.
-    assert(end.base() == buf + 8);
+    assert(base(end) == buf + 8);
   }
 
   // const version
   {
     SizedRandomAccessView view{buf, buf + 8};
     std::ranges::common_view<SizedRandomAccessView> const common(view);
     std::same_as<RandomAccessIter> auto end = common.end(); // Note this should NOT be the sentinel type.
-    assert(end.base() == buf + 8);
+    assert(base(end) == buf + 8);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());

libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp

 
 constexpr bool test() {
   // random_access_range<const V> && sized_range<const V>
   std::ranges::drop_view dropView1(MoveOnlyView(), 4);
   assert(dropView1.begin() == globalBuff + 4);
 
   // !random_access_range<const V>
   std::ranges::drop_view dropView2(ForwardView(), 4);
-  assert(dropView2.begin().base() == globalBuff + 4);
+  assert(base(dropView2.begin()) == globalBuff + 4);
 
   // !random_access_range<const V>
   std::ranges::drop_view dropView3(InputView(), 4);
-  assert(dropView3.begin().base() == globalBuff + 4);
+  assert(base(dropView3.begin()) == globalBuff + 4);
 
   // random_access_range<const V> && sized_range<const V>
   std::ranges::drop_view dropView4(MoveOnlyView(), 8);
   assert(dropView4.begin() == globalBuff + 8);
 
   // random_access_range<const V> && sized_range<const V>
   std::ranges::drop_view dropView5(MoveOnlyView(), 0);
   assert(dropView5.begin() == globalBuff);

libcxx/test/std/ranges/range.adaptors/range.drop/ctor.view.pass.cpp

 #include "types.h"
 
 constexpr bool test() {
   std::ranges::drop_view dropView1(MoveOnlyView(), 4);
   assert(dropView1.size() == 4);
   assert(dropView1.begin() == globalBuff + 4);
 
   std::ranges::drop_view dropView2(ForwardView(), 4);
-  assert(dropView2.begin().base() == globalBuff + 4);
+  assert(base(dropView2.begin()) == globalBuff + 4);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.drop/types.h

 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 struct InputView : std::ranges::view_base {
   constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(globalBuff); }
   constexpr int* end() const { return globalBuff + 8; }
 };
 // TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return base(rhs) == lhs; }
 
 struct Range {
   int *begin() const;
   int *end() const;
 };
 
 using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
 struct CountedView : std::ranges::view_base {
   constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
   constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
 };
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

struct ChildView : std::ranges::view_base {
   ChildView& operator=(ChildView&&) = default;
 
   constexpr cpp20_input_iterator<int *> begin() { return cpp20_input_iterator<int *>(ptr_); }
   constexpr cpp20_input_iterator<const int *> begin() const { return cpp20_input_iterator<const int *>(ptr_); }
   constexpr int *end() { return ptr_ + 4; }
   constexpr const int *end() const { return ptr_ + 4; }
 };
 
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return base(rhs) == lhs; }
 
 ChildView globalChildren[4] = {ChildView(globalBuffer[0]), ChildView(globalBuffer[1]), ChildView(globalBuffer[2]), ChildView(globalBuffer[3])};
 
 template<class T>
 struct ParentView : std::ranges::view_base {
   T *ptr_;
   unsigned size_;
 
struct ParentView : std::ranges::view_base {
 
   constexpr cpp20_input_iterator<T *> begin() { return cpp20_input_iterator<T *>(ptr_); }
   constexpr cpp20_input_iterator<const T *> begin() const { return cpp20_input_iterator<const T *>(ptr_); }
   constexpr T *end() { return ptr_ + size_; }
   constexpr const T *end() const { return ptr_ + size_; }
 };
 // TODO: remove these bogus operators
 template<class T>
-constexpr bool operator==(const cpp20_input_iterator<T*> &lhs, T *rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(const cpp20_input_iterator<T*> &lhs, T *rhs) { return base(lhs) == rhs; }
 template<class T>
-constexpr bool operator==(T *lhs, const cpp20_input_iterator<T*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(T *lhs, const cpp20_input_iterator<T*> &rhs) { return base(rhs) == lhs; }
 
 struct CopyableChild : std::ranges::view_base {
   int *ptr_;
   unsigned size_;
   constexpr CopyableChild(int *ptr = globalBuffer[0], unsigned size = 4)
     : ptr_(ptr), size_(size) {}
 
   constexpr cpp17_input_iterator<int *> begin() { return cpp17_input_iterator<int *>(ptr_); }
   constexpr cpp17_input_iterator<const int *> begin() const { return cpp17_input_iterator<const int *>(ptr_); }
   constexpr int *end() { return ptr_ + size_; }
   constexpr const int *end() const { return ptr_ + size_; }
 };
 // TODO: remove these bogus operators
-constexpr bool operator==(const cpp17_input_iterator<const int*> &lhs, const int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(const int* lhs, const cpp17_input_iterator<const int*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(const cpp17_input_iterator<const int*> &lhs, const int* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(const int* lhs, const cpp17_input_iterator<const int*> &rhs) { return base(rhs) == lhs; }
 
 struct CopyableParent : std::ranges::view_base {
   CopyableChild *ptr_;
   constexpr CopyableParent(CopyableChild *ptr) : ptr_(ptr) {}
 
   constexpr cpp17_input_iterator<CopyableChild *> begin() { return cpp17_input_iterator<CopyableChild *>(ptr_); }
   constexpr cpp17_input_iterator<const CopyableChild *> begin() const { return cpp17_input_iterator<const CopyableChild *>(ptr_); }
   constexpr CopyableChild *end() { return ptr_ + 4; }
   constexpr const CopyableChild *end() const { return ptr_ + 4; }
 };
 // TODO: remove these bogus operators
-constexpr bool operator==(const cpp17_input_iterator<const CopyableChild*> &lhs, const CopyableChild *rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(const CopyableChild *lhs, const cpp17_input_iterator<const CopyableChild*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(const cpp17_input_iterator<const CopyableChild*> &lhs, const CopyableChild *rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(const CopyableChild *lhs, const cpp17_input_iterator<const CopyableChild*> &rhs) { return base(rhs) == lhs; }
 
 struct Box { int x; };
 
 template<class T>
 struct InputValueIter {
   typedef std::input_iterator_tag iterator_category;
   typedef T value_type;
   typedef int difference_type;

libcxx/test/std/ranges/range.adaptors/range.reverse/adaptor.pass.cpp

// sized subrange over reverse iterators
 
     using ReverseIt = std::reverse_iterator<It>;
     using ReverseSubrange = std::ranges::subrange<ReverseIt, ReverseIt, std::ranges::subrange_kind::sized>;
 
     {
       BidirRange view(buf, buf + 3);
       ReverseSubrange subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)), /* size */3);
       std::same_as<Subrange> auto result = std::views::reverse(subrange);
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
     {
       // std::move into views::reverse
       BidirRange view(buf, buf + 3);
       ReverseSubrange subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)), /* size */3);
       std::same_as<Subrange> auto result = std::views::reverse(std::move(subrange));
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
     {
       // with a const subrange
       BidirRange view(buf, buf + 3);
       ReverseSubrange const subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)), /* size */3);
       std::same_as<Subrange> auto result = std::views::reverse(subrange);
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
   }
 
   // views::reverse(x) is equivalent to subrange{end, begin} if x is an
   // unsized subrange over reverse iterators
   {
     using It = bidirectional_iterator<int*>;
     using Subrange = std::ranges::subrange<It, It, std::ranges::subrange_kind::unsized>;
 
     using ReverseIt = std::reverse_iterator<It>;
     using ReverseSubrange = std::ranges::subrange<ReverseIt, ReverseIt, std::ranges::subrange_kind::unsized>;
 
     {
       BidirRange view(buf, buf + 3);
       ReverseSubrange subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)));
       std::same_as<Subrange> auto result = std::views::reverse(subrange);
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
     {
       // std::move into views::reverse
       BidirRange view(buf, buf + 3);
       ReverseSubrange subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)));
       std::same_as<Subrange> auto result = std::views::reverse(std::move(subrange));
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
     {
       // with a const subrange
       BidirRange view(buf, buf + 3);
       ReverseSubrange const subrange(ReverseIt(std::ranges::end(view)), ReverseIt(std::ranges::begin(view)));
       std::same_as<Subrange> auto result = std::views::reverse(subrange);
-      assert(result.begin().base() == buf);
-      assert(result.end().base() == buf + 3);
+      assert(base(result.begin()) == buf);
+      assert(base(result.end()) == buf + 3);
     }
   }
 
   // Otherwise, views::reverse(x) is equivalent to ranges::reverse_view{x}
   {
     BidirRange view(buf, buf + 3);
     std::same_as<std::ranges::reverse_view<BidirRange>> auto result = std::views::reverse(view);
-    assert(result.begin().base().base() == buf + 3);
-    assert(result.end().base().base() == buf);
+    assert(base(result.begin().base()) == buf + 3);
+    assert(base(result.end().base()) == buf);
   }
 
   // Test that std::views::reverse is a range adaptor
   {
     // Test `v | views::reverse`
     {
       BidirRange view(buf, buf + 3);
       std::same_as<std::ranges::reverse_view<BidirRange>> auto result = view | std::views::reverse;
-      assert(result.begin().base().base() == buf + 3);
-      assert(result.end().base().base() == buf);
+      assert(base(result.begin().base()) == buf + 3);
+      assert(base(result.end().base()) == buf);
     }
 
     // Test `adaptor | views::reverse`
     {
       BidirRange view(buf, buf + 3);
       auto f = [](int i) { return i; };
       auto const partial = std::views::transform(f) | std::views::reverse;
       using Result = std::ranges::reverse_view<std::ranges::transform_view<BidirRange, decltype(f)>>;
       std::same_as<Result> auto result = partial(view);
-      assert(result.begin().base().base().base() == buf + 3);
-      assert(result.end().base().base().base() == buf);
+      assert(base(result.begin().base().base()) == buf + 3);
+      assert(base(result.end().base().base()) == buf);
     }
 
     // Test `views::reverse | adaptor`
     {
       BidirRange view(buf, buf + 3);
       auto f = [](int i) { return i; };
       auto const partial = std::views::reverse | std::views::transform(f);
       using Result = std::ranges::transform_view<std::ranges::reverse_view<BidirRange>, decltype(f)>;
       std::same_as<Result> auto result = partial(view);
-      assert(result.begin().base().base().base() == buf + 3);
-      assert(result.end().base().base().base() == buf);
+      assert(base(result.begin().base().base()) == buf + 3);
+      assert(base(result.end().base().base()) == buf);
     }
 
     // Check SFINAE friendliness
     {
       struct NotABidirRange { };
       static_assert(!std::is_invocable_v<decltype(std::views::reverse)>);
       static_assert(!std::is_invocable_v<decltype(std::views::reverse), NotABidirRange>);
       static_assert( CanBePiped<BidirRange,     decltype(std::views::reverse)>);

libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp

 concept BeginInvocable = requires(T t) { t.begin(); };
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   // Common bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirRange{buffer, buffer + 8});
-    assert(rev.begin().base().base() == buffer + 8);
-    assert(std::move(rev).begin().base().base() == buffer + 8);
+    assert(base(rev.begin().base()) == buffer + 8);
+    assert(base(std::move(rev).begin().base()) == buffer + 8);
 
     ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
   // Const common bidirectional range.
   {
     const auto rev = std::ranges::reverse_view(BidirRange{buffer, buffer + 8});
-    assert(rev.begin().base().base() == buffer + 8);
-    assert(std::move(rev).begin().base().base() == buffer + 8);
+    assert(base(rev.begin().base()) == buffer + 8);
+    assert(base(std::move(rev).begin().base()) == buffer + 8);
 
     ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<const int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<const int*>>);
   }
   // Non-common, non-const (move only) bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirSentRange<MoveOnly>{buffer, buffer + 8});
-    assert(std::move(rev).begin().base().base() == buffer + 8);
+    assert(base(std::move(rev).begin().base()) == buffer + 8);
 
     ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
   // Non-common, non-const bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirSentRange<Copyable>{buffer, buffer + 8});
-    assert(rev.begin().base().base() == buffer + 8);
-    assert(std::move(rev).begin().base().base() == buffer + 8);
+    assert(base(rev.begin().base()) == buffer + 8);
+    assert(base(std::move(rev).begin().base()) == buffer + 8);
 
     ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
   // Non-common random access range.
   // Note: const overload invalid for non-common ranges, though it would not be imposible
   // to implement for random access ranges.
   {
     auto rev = std::ranges::reverse_view(RASentRange{buffer, buffer + 8});
-    assert(rev.begin().base().base() == buffer + 8);
-    assert(std::move(rev).begin().base().base() == buffer + 8);
+    assert(base(rev.begin().base()) == buffer + 8);
+    assert(base(std::move(rev).begin().base()) == buffer + 8);
 
     ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<random_access_iterator<int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<random_access_iterator<int*>>);
   }
   {
     static_assert( BeginInvocable<      std::ranges::reverse_view<BidirSentRange<Copyable>>>);
     static_assert(!BeginInvocable<const std::ranges::reverse_view<BidirSentRange<Copyable>>>);
   }

libcxx/test/std/ranges/range.adaptors/range.reverse/end.pass.cpp

 #include "types.h"
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   // Common bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirRange{buffer, buffer + 8});
-    assert(rev.end().base().base() == buffer);
-    assert(std::move(rev).end().base().base() == buffer);
+    assert(base(rev.end().base()) == buffer);
+    assert(base(std::move(rev).end().base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
   // Const common bidirectional range.
   {
     const auto rev = std::ranges::reverse_view(BidirRange{buffer, buffer + 8});
-    assert(rev.end().base().base() == buffer);
-    assert(std::move(rev).end().base().base() == buffer);
+    assert(base(rev.end().base()) == buffer);
+    assert(base(std::move(rev).end().base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<const int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<const int*>>);
   }
   // Non-common, non-const (move only) bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirSentRange<MoveOnly>{buffer, buffer + 8});
-    assert(std::move(rev).end().base().base() == buffer);
+    assert(base(std::move(rev).end().base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
   // Non-common, const bidirectional range.
   {
     auto rev = std::ranges::reverse_view(BidirSentRange<Copyable>{buffer, buffer + 8});
-    assert(rev.end().base().base() == buffer);
-    assert(std::move(rev).end().base().base() == buffer);
+    assert(base(rev.end().base()) == buffer);
+    assert(base(std::move(rev).end().base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<int*>>);
     ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp

constexpr bool test() {
   {
     std::ranges::transform_view transformView(MoveOnlyView{buff}, PlusOneMutable{});
     assert(transformView.begin().base() == buff);
     assert(*transformView.begin() == 1);
   }
 
   {
     std::ranges::transform_view transformView(ForwardView{buff}, PlusOneMutable{});
-    assert(transformView.begin().base().base() == buff);
+    assert(base(transformView.begin().base()) == buff);
     assert(*transformView.begin() == 1);
   }
 
   {
     std::ranges::transform_view transformView(InputView{buff}, PlusOneMutable{});
-    assert(transformView.begin().base().base() == buff);
+    assert(base(transformView.begin().base()) == buff);
     assert(*transformView.begin() == 1);
   }
 
   {
     const std::ranges::transform_view transformView(MoveOnlyView{buff}, PlusOne{});
     assert(*transformView.begin() == 1);
   }
 

libcxx/test/std/ranges/range.adaptors/range.transform/types.h

 
 struct SizedSentinelView : std::ranges::view_base {
   int count_;
   constexpr explicit SizedSentinelView(int count = 8) : count_(count) {}
   constexpr auto begin() const { return RandomAccessIter(globalBuff); }
   constexpr int *end() const { return globalBuff + count_; }
 };
 // TODO: remove these bogus operators
-constexpr auto operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
-constexpr auto operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
-constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
+constexpr auto operator- (const RandomAccessIter &lhs, int* rhs) { return base(lhs) - rhs; }
+constexpr auto operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - base(rhs); }
+constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return base(rhs) == lhs; }
 
 struct SizedSentinelNotConstView : std::ranges::view_base {
   ForwardIter begin() const;
   int *end() const;
   size_t size();
 };
 // TODO: remove these bogus operators
 bool operator==(const ForwardIter &lhs, int* rhs);

libcxx/test/std/ranges/range.utility/range.subrange/advance.pass.cpp

constexpr bool test() {
   assert(a5.begin() == globalBuff + 5);
   assert(a5.size() == 3);
   auto a4 = a5.prev();
   assert(a4.begin() == globalBuff + 4);
   assert(a4.size() == 4);
 
   std::ranges::subrange<InputIter, sentinel_wrapper<InputIter>> b(InputIter(globalBuff), sentinel_wrapper(InputIter(globalBuff + 8)));
   auto b1 = std::move(b).next();
-  assert(b1.begin().base() == globalBuff + 1);
+  assert(base(b1.begin()) == globalBuff + 1);
 
   std::ranges::subrange<BidirIter> c(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
   auto c1 = c.prev();
-  assert(c1.begin().base() == globalBuff + 3);
+  assert(base(c1.begin()) == globalBuff + 3);
   auto c2 = c.prev(4);
-  assert(c2.begin().base() == globalBuff);
+  assert(base(c2.begin()) == globalBuff);
 
   std::ranges::subrange<BidirIter> d(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
   auto d1 = d.advance(4);
-  assert(d1.begin().base() == globalBuff + 8);
+  assert(base(d1.begin()) == globalBuff + 8);
   assert(d1.empty());
   auto d2 = d1.advance(-4);
-  assert(d2.begin().base() == globalBuff + 4);
+  assert(base(d2.begin()) == globalBuff + 4);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.utility/range.subrange/ctor.begin_end.pass.cpp

 static_assert( std::is_constructible_v<ForwardSubrange, ForwardIter, ForwardIter>); // Default case.
 static_assert(!std::is_constructible_v<ForwardSubrange, Empty, ForwardIter>); // 1.
 static_assert( std::is_constructible_v<ConvertibleForwardSubrange, ConvertibleForwardIter, int*>); // 2.
 static_assert( std::is_constructible_v<ForwardSubrange, ForwardIter, ForwardIter>); // 3. (Same as default case.)
 // 4. and 5. must be sized.
 
 constexpr bool test() {
   ForwardSubrange a(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
-  assert(a.begin().base() == globalBuff);
-  assert(a.end().base() == globalBuff + 8);
+  assert(base(a.begin()) == globalBuff);
+  assert(base(a.end()) == globalBuff + 8);
 
   ConvertibleForwardSubrange b(ConvertibleForwardIter(globalBuff), globalBuff + 8);
   assert(b.begin() == globalBuff);
   assert(b.end() == globalBuff + 8);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pair_like_conv.pass.cpp

 static_assert(!std::is_convertible_v<ForwardSubrange, std::tuple<ForwardIter, ForwardIter, ForwardIter>>);
 static_assert( std::is_convertible_v<ConvertibleForwardSubrange, std::tuple<ConvertibleForwardIter, int*>>);
 static_assert(!std::is_convertible_v<SizedIntPtrSubrange, std::tuple<long*, int*>>);
 static_assert( std::is_convertible_v<SizedIntPtrSubrange, std::tuple<int*, int*>>);
 
 constexpr bool test() {
   ForwardSubrange a(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
   std::pair<ForwardIter, ForwardIter> aPair = a;
-  assert(aPair.first.base() == globalBuff);
-  assert(aPair.second.base() == globalBuff + 8);
+  assert(base(aPair.first) == globalBuff);
+  assert(base(aPair.second) == globalBuff + 8);
   std::tuple<ForwardIter, ForwardIter> aTuple = a;
-  assert(std::get<0>(aTuple).base() == globalBuff);
-  assert(std::get<1>(aTuple).base() == globalBuff + 8);
+  assert(base(std::get<0>(aTuple)) == globalBuff);
+  assert(base(std::get<1>(aTuple)) == globalBuff + 8);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.utility/range.subrange/ctor.range.pass.cpp

 // Iter convertible to sentinel (pointer) type.
 static_assert( std::is_constructible_v<ConvertibleForwardSubrange, ConvertibleForwardBorrowedRange>);
 // Where neither iter or sentinel are pointers, but they are different.
 static_assert( std::is_constructible_v<DifferentSentinelSubrange, ForwardBorrowedRangeDifferentSentinel>);
 static_assert( std::is_constructible_v<DifferentSentinelWithSizeMemberSubrange, DifferentSentinelWithSizeMember>);
 
 constexpr bool test() {
   ForwardSubrange a{ForwardBorrowedRange()};
-  assert(a.begin().base() == globalBuff);
-  assert(a.end().base() == globalBuff + 8);
+  assert(base(a.begin()) == globalBuff);
+  assert(base(a.end()) == globalBuff + 8);
 
   ConvertibleForwardSubrange b{ConvertibleForwardBorrowedRange()};
   assert(b.begin() == globalBuff);
   assert(b.end() == globalBuff + 8);
 
   DifferentSentinelSubrange c{ForwardBorrowedRangeDifferentSentinel()};
-  assert(c.begin().base() == globalBuff);
+  assert(base(c.begin()) == globalBuff);
   assert(c.end().value == globalBuff + 8);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.utility/range.subrange/primitives.pass.cpp

 #include "test_iterators.h"
 #include "types.h"
 
 constexpr bool test() {
   int buff[] = {1, 2, 3, 4, 5};
 
   {
     std::ranges::subrange<MoveOnlyForwardIter, int*> a(MoveOnlyForwardIter(buff), buff + 5, 5);
-    assert(a.begin().base == buff);
+    assert(base(a.begin()) == buff);
     assert(!a.empty());
     assert(a.size() == 5);
   }
 
   {
     std::ranges::subrange<ForwardIter> b(ForwardIter(nullptr), ForwardIter(nullptr));
     assert(b.empty());
   }

libcxx/test/std/ranges/range.utility/range.subrange/types.h

 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<ConvertibleForwardBorrowedRange> = true;
 
 struct ForwardBorrowedRangeDifferentSentinel {
   struct sentinel {
     int *value;
-    friend bool operator==(sentinel s, ForwardIter i) { return s.value == i.base(); }
+    friend bool operator==(sentinel s, ForwardIter i) { return s.value == base(i); }
   };
 
   constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
   constexpr sentinel end() const { return sentinel{globalBuff + 8}; }
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<ForwardBorrowedRangeDifferentSentinel> = true;
 
 using DifferentSentinelSubrange = std::ranges::subrange<ForwardIter,
                                                         ForwardBorrowedRangeDifferentSentinel::sentinel,
                                                         std::ranges::subrange_kind::unsized>;
 
 struct DifferentSentinelWithSizeMember {
   struct sentinel {
     int *value;
-    friend bool operator==(sentinel s, ForwardIter i) { return s.value == i.base(); }
+    friend bool operator==(sentinel s, ForwardIter i) { return s.value == base(i); }
   };
 
   constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
   constexpr sentinel end() const { return sentinel{globalBuff + 8}; }
   constexpr size_t size() const { return 8; }
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<DifferentSentinelWithSizeMember> = true;
 
 using DifferentSentinelWithSizeMemberSubrange = std::ranges::subrange<ForwardIter,
                                                                       DifferentSentinelWithSizeMember::sentinel,
                                                                       std::ranges::subrange_kind::unsized>;
 
 #endif // LIBCXX_TEST_STD_RANGES_RANGE_UTILITY_RANGE_SUBRANGE_TYPES_H

libcxx/test/std/ranges/range.utility/view.interface/view.interface.pass.cpp

struct NotSizedSentinel {
   bool operator==(NotSizedSentinel const&) const;
 };
 static_assert(std::forward_iterator<NotSizedSentinel>);
 
 using ForwardIter = forward_iterator<int*>;
 
 // So that we conform to sized_sentinel_for.
 constexpr std::ptrdiff_t operator-(const ForwardIter& x, const ForwardIter& y) {
-    return x.base() - y.base();
+    return base(x) - base(y);
 }
 
 struct ForwardRange : std::ranges::view_interface<ForwardRange> {
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
   constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); }
   constexpr ForwardIter end() const { return ForwardIter(const_cast<int*>(buff) + 8); }
 };
 static_assert(std::ranges::view<ForwardRange>);
struct ResultType {
     bool value;
     constexpr operator bool() const { return value; }
   };
 
   struct SentinelType {
     int *base_;
     explicit SentinelType() = default;
     constexpr explicit SentinelType(int *base) : base_(base) {}
-    friend constexpr ResultType operator==(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() == sent.base_}; }
-    friend constexpr ResultType operator==(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() == sent.base_}; }
-    friend constexpr ResultType operator!=(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() != sent.base_}; }
-    friend constexpr ResultType operator!=(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() != sent.base_}; }
+    friend constexpr ResultType operator==(ForwardIter const& iter, SentinelType const& sent) noexcept { return {base(iter) == sent.base_}; }
+    friend constexpr ResultType operator==(SentinelType const& sent, ForwardIter const& iter) noexcept { return {base(iter) == sent.base_}; }
+    friend constexpr ResultType operator!=(ForwardIter const& iter, SentinelType const& sent) noexcept { return {base(iter) != sent.base_}; }
+    friend constexpr ResultType operator!=(SentinelType const& sent, ForwardIter const& iter) noexcept { return {base(iter) != sent.base_}; }
   };
 
   int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
   constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); }
   constexpr SentinelType end() const { return SentinelType(const_cast<int*>(buff) + 8); }
 };
 static_assert(std::ranges::view<BoolConvertibleComparison>);
 

libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp

int main(int, char**)
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-$&"));
-        assert(r.base() == buf+40);
+        assert(base(r) == buf+40);
         assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-$&"),
                                     std::regex_constants::format_sed);
-        assert(r.base() == buf+43);
+        assert(base(r) == buf+43);
         assert(buf == std::string("123-$555-1234, 123-$555-2345, 123-$555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-&"),
                                     std::regex_constants::format_sed);
-        assert(r.base() == buf+40);
+        assert(base(r) == buf+40);
         assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-$&"),
                                     std::regex_constants::format_no_copy);
-        assert(r.base() == buf+36);
+        assert(base(r) == buf+36);
         assert(buf == std::string("123-555-1234123-555-2345123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-$&"),
                                     std::regex_constants::format_first_only);
-        assert(r.base() == buf+32);
+        assert(base(r) == buf+32);
         assert(buf == std::string("123-555-1234, 555-2345, 555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     std::string("123-$&"),
                                     std::regex_constants::format_first_only |
                                     std::regex_constants::format_no_copy);
-        assert(r.base() == buf+12);
+        assert(base(r) == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
 
   return 0;
 }

libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp

int main(int, char**)
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-$&");
-        assert(r.base() == buf+40);
+        assert(base(r) == buf+40);
         assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-$&",
                                     std::regex_constants::format_sed);
-        assert(r.base() == buf+43);
+        assert(base(r) == buf+43);
         assert(buf == std::string("123-$555-1234, 123-$555-2345, 123-$555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-&",
                                     std::regex_constants::format_sed);
-        assert(r.base() == buf+40);
+        assert(base(r) == buf+40);
         assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-$&",
                                     std::regex_constants::format_no_copy);
-        assert(r.base() == buf+36);
+        assert(base(r) == buf+36);
         assert(buf == std::string("123-555-1234123-555-2345123-555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-$&",
                                     std::regex_constants::format_first_only);
-        assert(r.base() == buf+32);
+        assert(base(r) == buf+32);
         assert(buf == std::string("123-555-1234, 555-2345, 555-3456"));
     }
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef cpp17_output_iterator<char*> Out;
         typedef bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
                                     "123-$&",
                                     std::regex_constants::format_first_only |
                                     std::regex_constants::format_no_copy);
-        assert(r.base() == buf+12);
+        assert(base(r) == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
 
   return 0;
 }

libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp

 int main(int, char**)
 {
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt)).base();
-        assert(r == out + 58);
+        auto r = m.format(cpp17_output_iterator<char*>(out),
+                    fmt, fmt + std::char_traits<char>::length(fmt));
+        assert(base(r) == out + 58);
         assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi",
                                                   std::regex_constants::nosubs)));
 
         char out[100] = {0};
         const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt)).base();
-        assert(r == out + 54);
+        auto r = m.format(cpp17_output_iterator<char*>(out),
+                    fmt, fmt + std::char_traits<char>::length(fmt));
+        assert(base(r) == out + 54);
         assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cdefghi")));
 
         char out[100] = {0};
         const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt)).base();
-        assert(r == out + 54);
+        auto r = m.format(cpp17_output_iterator<char*>(out),
+                    fmt, fmt + std::char_traits<char>::length(fmt));
+        assert(base(r) == out + 54);
         assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
+        auto r = m.format(cpp17_output_iterator<char*>(out),
                     fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 59);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 59);
         assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
+        auto r = m.format(cpp17_output_iterator<char*>(out),
                     fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 34);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 34);
         assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi",
                                                   std::regex_constants::nosubs)));
 
         char out[100] = {0};
         const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
+        auto r = m.format(cpp17_output_iterator<char*>(out),
                     fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 30);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 30);
         assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cdefghi")));
 
         char out[100] = {0};
         const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        char* r = m.format(cpp17_output_iterator<char*>(out),
+        auto r = m.format(cpp17_output_iterator<char*>(out),
                     fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 30);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 30);
         assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, fmt + std::char_traits<wchar_t>::length(fmt)).base();
-        assert(r == out + 58);
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
+                    fmt, fmt + std::char_traits<wchar_t>::length(fmt));
+        assert(base(r) == out + 58);
         assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
     }
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out),
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
                     fmt, fmt + std::char_traits<wchar_t>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 59);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 59);
         assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
     }
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         const wchar_t fmt[] = L"match: &, m[1]: \\1, m[2]: \\2";
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out),
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
                     fmt, fmt + std::char_traits<wchar_t>::length(fmt),
-                    std::regex_constants::format_sed).base();
-        assert(r == out + 34);
+                    std::regex_constants::format_sed);
+        assert(base(r) == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp

int main(int, char**)
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        char* r = m.format(cpp17_output_iterator<char*>(out), fmt).base();
-        assert(r == out + 58);
+        auto r = m.format(cpp17_output_iterator<char*>(out), fmt);
+        assert(base(r) == out + 58);
         assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        char* r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, std::regex_constants::format_sed).base();
-        assert(r == out + 59);
+        auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
+        assert(base(r) == out + 59);
         assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
     }
     {
         std::match_results<const char*> m;
         const char s[] = "abcdefghijk";
         assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
         char out[100] = {0};
         nstr fmt("match: &, m[1]: \\1, m[2]: \\2");
-        char* r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, std::regex_constants::format_sed).base();
-        assert(r == out + 34);
+        auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
+        assert(base(r) == out + 34);
         assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt).base();
-        assert(r == out + 58);
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt);
+        assert(base(r) == out + 58);
         assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
     }
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, std::regex_constants::format_sed).base();
-        assert(r == out + 59);
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
+        assert(base(r) == out + 59);
         assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
     }
     {
         std::match_results<const wchar_t*> m;
         const wchar_t s[] = L"abcdefghijk";
         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
         wchar_t out[100] = {0};
         wstr fmt(L"match: &, m[1]: \\1, m[2]: \\2");
-        wchar_t* r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, std::regex_constants::format_sed).base();
-        assert(r == out + 34);
+        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
+        assert(base(r) == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/support/test_iterators.h

public:
     template <class U>
         TEST_CONSTEXPR cpp17_output_iterator(const cpp17_output_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR reference operator*() const {return *it_;}
 
     TEST_CONSTEXPR_CXX14 cpp17_output_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 cpp17_output_iterator operator++(int) {return cpp17_output_iterator(it_++);}
 
-    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const cpp17_output_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 #ifndef _LIBCPP_HAS_NO_CONCEPTS
    static_assert(std::output_iterator<cpp17_output_iterator<int*>, int>);
 #endif
public:
     TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 cpp17_input_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int) {return cpp17_input_iterator(it_++);}
 
     friend TEST_CONSTEXPR bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ != y.it_;}
 
-    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const cpp17_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 #ifndef _LIBCPP_HAS_NO_CONCEPTS
    static_assert(std::input_iterator<cpp17_input_iterator<int*>>);
 #endif
public:
     TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 forward_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 forward_iterator operator++(int) {return forward_iterator(it_++);}
 
     friend TEST_CONSTEXPR bool operator==(const forward_iterator& x, const forward_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const forward_iterator& x, const forward_iterator& y) {return x.it_ != y.it_;}
 
-    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const forward_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 template <class It>
 class bidirectional_iterator
public:
     TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator--() {--it_; return *this;}
     TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int) {return bidirectional_iterator(it_++);}
     TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int) {return bidirectional_iterator(it_--);}
 
     friend TEST_CONSTEXPR bool operator==(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ != y.it_;}
 
-    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const bidirectional_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 template <class It>
 class random_access_iterator
public:
 
     friend TEST_CONSTEXPR bool operator==(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ != y.it_;}
     friend TEST_CONSTEXPR bool operator< (const random_access_iterator& x, const random_access_iterator& y) {return x.it_ <  y.it_;}
     friend TEST_CONSTEXPR bool operator<=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ <= y.it_;}
     friend TEST_CONSTEXPR bool operator> (const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >  y.it_;}
     friend TEST_CONSTEXPR bool operator>=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >= y.it_;}
 
-    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const random_access_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 #if TEST_STD_VER > 17
 template <class It>
public:
 
     constexpr explicit cpp20_input_iterator(It it) : it_(it) {}
     cpp20_input_iterator(cpp20_input_iterator&&) = default;
     cpp20_input_iterator& operator=(cpp20_input_iterator&&) = default;
     constexpr decltype(auto) operator*() const { return *it_; }
     constexpr cpp20_input_iterator& operator++() { ++it_; return *this; }
     constexpr void operator++(int) { ++it_; }
 
-    constexpr const It& base() const& { return it_; } // TODO remove me
     friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };