[libc++][ranges] Implement Ranges changes to `istream{,buf}_iterator`.

[var-const]

Summary

The changes from the One Ranges Proposal amount to adding:

• a constructor that takes a default_sentinel_t and is equivalent to the default constructor;
• an operator== that compares the iterator to default_sentinel_t.

The original proposal defined two overloads for operator== (different
argument order) as well as operator!=. This has been removed by
P1614.

[var-const]

Use the actual patch number.

[var-const]

Mark changes to stream iterators as done.

[var-const]

libcxx/include/__iterator/istream_iterator.h

50

Note: the default constructor and this constructor are defined in the same clause in the Standard (23.6.2.2.1, http://eel.is/c++draft/istream.iterator#cons-1), so it made sense to define one in terms of the other.

libcxx/include/__iterator/istreambuf_iterator.h

97

This is the definition from the Standard verbatim (http://eel.is/c++draft/istreambuf.iterator#ops-7). At least conceptually, it involves creating a istreambuf_iterator from the sentinel. We could instead do something like return __test_for_eof();. I'm not sure if it's worth it, though.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

57

Because these constructors (default constructor and default_sentinel_t constructor) are defined in the same clause, I'm leaning towards testing them in the same test file.

[var-const]

Add noexcept tests.

[var-const]

Small fixes to the synopsis.

[• Quuxplusone]

LGTM % minor comments!
Please fix (especially the operator!=s), rebase and re-upload to see a green CI run (now that the ASAN failures should be fixed, right?), but then this seems ready to ship.

libcxx/include/__iterator/istream_iterator.h

77

Nit: I know the standard says !in_stream, but can we please make this return __i.__in_stream_ == nullptr; for clarity? (Since it's just a raw pointer, there's no difference except readability.)

91–98

operator!= should be under #if _LIBCPP_STD_VER <= 17, because it's gone in '20.

libcxx/include/__iterator/istreambuf_iterator.h

70

97

I agree; but I think it is worth it, just to get rid of a layer of indirection and avoid having to name the __s parameter. :) return __i.__test_for_eof(); sounds like a win to me.

108–112

As above, this operator!= is gone in '20.

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

13–15

Nit: To match the synopsis comment, and the throw()/noexcept distinction isn't terribly important IMHO.

[• Quuxplusone]

Er, actually, I spoke too soon...! There are also test failures on Apple, because you changed the operator==/!= tests to include references to default_sentinel, and default_sentinel is disabled when libcpp-has-no-concepts.
I suggest fixing this by changing <__iterator/default_sentinel.h> to enable default_sentinel in C++20 regardless of _LIBCPP_HAS_NO_CONCEPTS — it should merely be guarded by #if _LIBCPP_STD_VER > 17 and nothing else. However, now this has become a more involved change, and I think at least I should re-review it once the CI is green, and perhaps also someone else.

(Alternatively, you could split out the default_sentinel-related tests into separate test files and skip them for libcpp-has-no-concepts targets. But that seems yuckier.)

[var-const]

In D119620#3317884, @Quuxplusone wrote:

I suggest fixing this by changing <__iterator/default_sentinel.h> to enable default_sentinel in C++20 regardless of _LIBCPP_HAS_NO_CONCEPTS — it should merely be guarded by #if _LIBCPP_STD_VER > 17 and nothing else.

Done. Since it doesn't actually use concepts, that seems reasonable.

libcxx/include/__iterator/istream_iterator.h

77

Sure.

91–98

Done (I don't think this is related to the One Ranges proposal, but it makes sense to do these changes in one go). Also mentioned this in the synopsis.

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

13–15

Done. I've done the same change in the synopsis -- you intended to change both, right?

[var-const]

Address feedback (in particular, remove the throw()/noexcept distinction
from the synopsis and guard default_sentinel on the language version, not the
availability of concepts).

[ldionne]

This LGTM. I'm fine with not guarding default_sentinel_t under _LIBCPP_HAS_NO_CONCEPTS, since (1) that macro will soon die and (2) it technically doesn't need concepts.

Leaving final approval to Arthur since he had comments.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

57

I have a very slight preference for different files since they are really different constructors (except they happen to have the same effect). But definitely not a blocking comment.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp

11

If you add the test here (I'd weakly prefer another file), please update the synopsis. This applies in a couple other tests too.

[var-const]

Address feedback, fix the CI.

[var-const]

Rebase on main.

[• Quuxplusone]

I just landed D118736, so please check relatively carefully for merge conflicts; but I don't think you'll find any.

[var-const]

Rebase on main.

libcxx/docs/Status/RangesPaper.csv

 | [iterator.cust.swap]
 | [iterator.cust.move]",Zoe Carver,✅
 `[default.sentinel] <https://wg21.link/default.sentinel>`_,`std::default_sentinel_t <https://llvm.org/D103487>`_,No dependencies,Zoe Carver,✅
 `[counted.iterator] <https://wg21.link/counted.iterator>`_,`counted_iterator <https://llvm.org/D106205>`_,"| [iterator.concepts]
 | [iterator.cust.swap]
 | [iterator.cust.move]
 | [default.sentinels]",Zoe Carver,✅
 `[stream.iterators] <https://wg21.link/stream.iterators>`_,"
-| Updates to istream_iterator
-| `Updates to ostream_iterator <https://llvm.org/https://llvm.org/D103273>`_
-| Updates to istreambuf_iterator
-| `Updates to ostreambuf_iterator <https://llvm.org/https://llvm.org/D103273>`_
+| `Updates to istream_iterator <https://llvm.org/TODO>`_
+| `Updates to ostream_iterator <https://llvm.org/D103273>`_
+| `Updates to istreambuf_iterator <https://llvm.org/TODO>`_
+| `Updates to ostreambuf_iterator <https://llvm.org/D103273>`_
 ",[default.sentinels],Various,In progress
 `[range.access] <https://wg21.link/range.access>`_,"| `ranges::begin <https://llvm.org/D100255>`_
 | `ranges::end <https://llvm.org/D100255>`_
 | `range::cbegin <https://llvm.org/D100255>`_
 | `ranges::cend <https://llvm.org/D100255>`_
 | ranges::rbegin
 | ranges::rend
 | ranges::crbegin

libcxx/include/__iterator/istream_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
 #define _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
 
 #include <__config>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <iosfwd> // for forward declarations of char_traits and basic_istream
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
public:
     typedef _CharT char_type;
     typedef _Traits traits_type;
     typedef basic_istream<_CharT,_Traits> istream_type;
 private:
     istream_type* __in_stream_;
     _Tp __value_;
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+    _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
     _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
         {
             if (!(*__in_stream_ >> __value_))
                 __in_stream_ = nullptr;
         }
 
     _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
     _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
     _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
         {
             if (!(*__in_stream_ >> __value_))
                 __in_stream_ = nullptr;
             return *this;
         }
     _LIBCPP_INLINE_VISIBILITY istream_iterator  operator++(int)
         {istream_iterator __t(*this); ++(*this); return __t;}
 
     template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
     friend _LIBCPP_INLINE_VISIBILITY
     bool
     operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
                const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
+      return !__i.__in_stream_;
+    }
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 };
 
 template <class _Tp, class _CharT, class _Traits, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return __x.__in_stream_ == __y.__in_stream_;
 }
 
 template <class _Tp, class _CharT, class _Traits, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return !(__x == __y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H

libcxx/include/__iterator/istreambuf_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
 #define _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
 
 #include <__config>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <iosfwd> // for forward declaration of basic_streambuf
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
private:
     bool __test_for_eof() const
     {
         if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
             __sbuf_ = nullptr;
         return __sbuf_ == nullptr;
     }
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+    _LIBCPP_INLINE_VISIBILITY constexpr istreambuf_iterator(default_sentinel_t) _NOEXCEPT
+        : istreambuf_iterator() {}
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
         : __sbuf_(__s.rdbuf()) {}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
         : __sbuf_(__s) {}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
         : __sbuf_(__p.__sbuf_) {}
 
     _LIBCPP_INLINE_VISIBILITY char_type  operator*() const
         {return static_cast<char_type>(__sbuf_->sgetc());}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
         {
             __sbuf_->sbumpc();
             return *this;
         }
     _LIBCPP_INLINE_VISIBILITY __proxy              operator++(int)
         {
             return __proxy(__sbuf_->sbumpc(), __sbuf_);
         }
 
     _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
         {return __test_for_eof() == __b.__test_for_eof();}
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t __s) {
+      return __i.equal(__s);
+    }
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 };
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
                 const istreambuf_iterator<_CharT,_Traits>& __b)
                 {return __a.equal(__b);}
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
                 const istreambuf_iterator<_CharT,_Traits>& __b)
                 {return !__a.equal(__b);}
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H

libcxx/include/iterator

public:
     typedef const T*                     pointer;
     typedef const T&                     reference;
 
     typedef charT                        char_type;
     typedef traits                       traits_type;
     typedef basic_istream<charT, traits> istream_type;
 
     constexpr istream_iterator();
+    constexpr istream_iterator(default_sentinel_t); // since C++20
     istream_iterator(istream_type& s);
     istream_iterator(const istream_iterator& x);
     ~istream_iterator();
 
     const T& operator*() const;
     const T* operator->() const;
     istream_iterator& operator++();
     istream_iterator  operator++(int);
+    friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20
 };
 
 template <class T, class charT, class traits, class Distance>
 bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
                 const istream_iterator<T,charT,traits,Distance>& y);
 template <class T, class charT, class traits, class Distance>
 bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
                 const istream_iterator<T,charT,traits,Distance>& y);
public:
 
     typedef charT                           char_type;
     typedef traits                          traits_type;
     typedef traits::int_type                int_type;
     typedef basic_streambuf<charT, traits>  streambuf_type;
     typedef basic_istream<charT, traits>    istream_type;
 
     istreambuf_iterator() noexcept;
+    istreambuf_iterator(default_sentinel_t) noexcept; // since C++20
     istreambuf_iterator(istream_type& s) noexcept;
     istreambuf_iterator(streambuf_type* s) noexcept;
     istreambuf_iterator(a-private-type) noexcept;
 
     charT                operator*() const;
     pointer operator->() const;
     istreambuf_iterator& operator++();
     a-private-type       operator++(int);
 
     bool equal(const istreambuf_iterator& b) const;
+    friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20
 };
 
 template <class charT, class traits>
 bool operator==(const istreambuf_iterator<charT,traits>& a,
                 const istreambuf_iterator<charT,traits>& b);
 template <class charT, class traits>
 bool operator!=(const istreambuf_iterator<charT,traits>& a,
                 const istreambuf_iterator<charT,traits>& b);

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // class istream_iterator
 
 // constexpr istream_iterator();
 // C++17 says: If is_trivially_default_constructible_v<T> is true, then this
 //    constructor is a constexpr constructor.
+//
+// constexpr istream_iterator(default_sentinel_t); // since C++20
 
 #include <iterator>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 
 struct S { S(); }; // not constexpr
int main(int, char**)
     T it;
     assert(it == T());
 #if TEST_STD_VER >= 11
     constexpr T it2;
     (void)it2;
 #endif
     }
 
+#if TEST_STD_VER > 17
+    {
+    typedef std::istream_iterator<int> T;
+
+    T it1(std::default_sentinel);
+    assert(it1 == T());
+
+    T it2 = std::default_sentinel;
+    assert(it2 == it1);
+
+    constexpr T it3(std::default_sentinel);
+    (void)it3;
+    }
+#endif
+
 #if TEST_STD_VER > 14
     test_trivial<int>()();
     test_trivial<char>()();
     test_trivial<double>()();
     test_trivial<S>()();
     test_trivial<std::string>()();
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // class istream_iterator
 
 // template <class T, class charT, class traits, class Distance>
 //   bool operator==(const istream_iterator<T,charT,traits,Distance> &x,
 //                   const istream_iterator<T,charT,traits,Distance> &y);
 //
 // template <class T, class charT, class traits, class Distance>
 //   bool operator!=(const istream_iterator<T,charT,traits,Distance> &x,
 //                   const istream_iterator<T,charT,traits,Distance> &y);
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+int main(int, char**) {
   {
     std::istringstream inf1(" 1 23");
     std::istringstream inf2(" 1 23");
     std::istream_iterator<int> i1(inf1);
     std::istream_iterator<int> i2(inf1);
     std::istream_iterator<int> i3(inf2);
     std::istream_iterator<int> i4;
     std::istream_iterator<int> i5;
     assert(i1 == i1);
int main(int, char**) {
     assert(i3 != i4);
     assert(i3 != i5);
 
     assert(i4 == i4);
     assert(i4 == i5);
 
     assert(std::operator==(i1, i2));
     assert(std::operator!=(i1, i3));
+  }
+
+#if TEST_STD_VER > 17
+  {
+    std::istream_iterator<int> i1;
+    std::istream_iterator<int> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(i1 == std::default_sentinel);
+    assert(i2 == std::default_sentinel);
+    assert(std::default_sentinel == i1);
+    assert(std::default_sentinel == i2);
+    assert(!(i1 != std::default_sentinel));
+    assert(!(i2 != std::default_sentinel));
+    assert(!(std::default_sentinel != i1));
+    assert(!(std::default_sentinel != i2));
+
+    std::istringstream stream(" 1 23");
+    std::istream_iterator<int> i3(stream);
+
+    assert(!(i3 == std::default_sentinel));
+    assert(!(std::default_sentinel == i3));
+    assert(i3 != std::default_sentinel);
+    assert(std::default_sentinel != i3);
+  }
+#endif
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // istreambuf_iterator
 //
 // istreambuf_iterator() throw();
+// istreambuf_iterator(default_sentinel_t) noexcept(); // since C++20
 //
 // All specializations of istreambuf_iterator shall have a trivial copy constructor,
 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::istreambuf_iterator<char> T;
         T it;
         assert(it == T());
 #if TEST_STD_VER >= 11
         constexpr T it2;
         (void)it2;
 #endif
     }
 
+#if TEST_STD_VER > 17
+    {
+        typedef std::istreambuf_iterator<char> T;
+
+        T it1(std::default_sentinel);
+        assert(it1 == T());
+
+        T it2 = std::default_sentinel;
+        assert(it2 == it1);
+
+        constexpr T it3(std::default_sentinel);
+        (void)it3;
+    }
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         typedef std::istreambuf_iterator<wchar_t> T;
         T it;
         assert(it == T());
 #if TEST_STD_VER >= 11
         constexpr T it2;
         (void)it2;
 #endif
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // istreambuf_iterator
 
 // template <class charT, class traits>
 //   bool operator!=(const istreambuf_iterator<charT,traits>& a,
 //                   const istreambuf_iterator<charT,traits>& b);
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream inf1("abc");
-        std::istringstream inf2("def");
-        std::istreambuf_iterator<char> i1(inf1);
-        std::istreambuf_iterator<char> i2(inf2);
-        std::istreambuf_iterator<char> i3;
-        std::istreambuf_iterator<char> i4;
-        std::istreambuf_iterator<char> i5(nullptr);
+int main(int, char**) {
 
-        assert(!(i1 != i1));
-        assert(!(i1 != i2));
-        assert( (i1 != i3));
-        assert( (i1 != i4));
-        assert( (i1 != i5));
 
-        assert(!(i2 != i1));
-        assert(!(i2 != i2));
-        assert( (i2 != i3));
-        assert( (i2 != i4));
-        assert( (i2 != i5));
 
-        assert( (i3 != i1));
-        assert( (i3 != i2));
-        assert(!(i3 != i3));
-        assert(!(i3 != i4));
-        assert(!(i3 != i5));
 
-        assert( (i4 != i1));
-        assert( (i4 != i2));
-        assert(!(i4 != i3));
-        assert(!(i4 != i4));
-        assert(!(i4 != i5));
 
-        assert( (i5 != i1));
-        assert( (i5 != i2));
-        assert(!(i5 != i3));
-        assert(!(i5 != i4));
-        assert(!(i5 != i5));
-    }
+
+#if TEST_STD_VER > 17
+  {
+    std::istreambuf_iterator<char> i1;
+    std::istreambuf_iterator<char> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(!(i1 != std::default_sentinel));
+    assert(!(i2 != std::default_sentinel));
+    assert(!(std::default_sentinel != i1));
+    assert(!(std::default_sentinel != i2));
+
+    std::istringstream stream(" 1 23");
+    std::istreambuf_iterator<char> i3(stream);
+
+    assert(i3 != std::default_sentinel);
+    assert(std::default_sentinel != i3);
+  }
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream inf1(L"abc");
-        std::wistringstream inf2(L"def");
-        std::istreambuf_iterator<wchar_t> i1(inf1);
-        std::istreambuf_iterator<wchar_t> i2(inf2);
-        std::istreambuf_iterator<wchar_t> i3;
-        std::istreambuf_iterator<wchar_t> i4;
-        std::istreambuf_iterator<wchar_t> i5(nullptr);
 
-        assert(!(i1 != i1));
-        assert(!(i1 != i2));
-        assert( (i1 != i3));
-        assert( (i1 != i4));
-        assert( (i1 != i5));
 
-        assert(!(i2 != i1));
-        assert(!(i2 != i2));
-        assert( (i2 != i3));
-        assert( (i2 != i4));
-        assert( (i2 != i5));
 
-        assert( (i3 != i1));
-        assert( (i3 != i2));
-        assert(!(i3 != i3));
-        assert(!(i3 != i4));
-        assert(!(i3 != i5));
 
-        assert( (i4 != i1));
-        assert( (i4 != i2));
-        assert(!(i4 != i3));
-        assert(!(i4 != i4));
-        assert(!(i4 != i5));
 
-        assert( (i5 != i1));
-        assert( (i5 != i2));
-        assert(!(i5 != i3));
-        assert(!(i5 != i4));
-        assert(!(i5 != i5));
-    }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // istreambuf_iterator
 
 // template <class charT, class traits>
 //   bool operator==(const istreambuf_iterator<charT,traits>& a,
 //                   const istreambuf_iterator<charT,traits>& b);
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream inf1("abc");
-        std::istringstream inf2("def");
-        std::istreambuf_iterator<char> i1(inf1);
-        std::istreambuf_iterator<char> i2(inf2);
-        std::istreambuf_iterator<char> i3;
-        std::istreambuf_iterator<char> i4;
-        std::istreambuf_iterator<char> i5(nullptr);
+int main(int, char**) {
 
-        assert( (i1 == i1));
-        assert( (i1 == i2));
-        assert(!(i1 == i3));
-        assert(!(i1 == i4));
-        assert(!(i1 == i5));
 
-        assert( (i2 == i1));
-        assert( (i2 == i2));
-        assert(!(i2 == i3));
-        assert(!(i2 == i4));
-        assert(!(i2 == i5));
 
-        assert(!(i3 == i1));
-        assert(!(i3 == i2));
-        assert( (i3 == i3));
-        assert( (i3 == i4));
-        assert( (i3 == i5));
 
-        assert(!(i4 == i1));
-        assert(!(i4 == i2));
-        assert( (i4 == i3));
-        assert( (i4 == i4));
-        assert( (i4 == i5));
 
-        assert(!(i5 == i1));
-        assert(!(i5 == i2));
-        assert( (i5 == i3));
-        assert( (i5 == i4));
-        assert( (i5 == i5));
-    }
+
+#if TEST_STD_VER > 17
+  {
+    std::istreambuf_iterator<char> i1;
+    std::istreambuf_iterator<char> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(i1 == std::default_sentinel);
+    assert(i2 == std::default_sentinel);
+    assert(std::default_sentinel == i1);
+    assert(std::default_sentinel == i2);
+
+    std::istringstream stream(" 1 23");
+    std::istreambuf_iterator<char> i3(stream);
+
+    assert(!(i3 == std::default_sentinel));
+    assert(!(std::default_sentinel == i3));
+  }
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream inf1(L"abc");
-        std::wistringstream inf2(L"def");
-        std::istreambuf_iterator<wchar_t> i1(inf1);
-        std::istreambuf_iterator<wchar_t> i2(inf2);
-        std::istreambuf_iterator<wchar_t> i3;
-        std::istreambuf_iterator<wchar_t> i4;
-        std::istreambuf_iterator<wchar_t> i5(nullptr);
 
-        assert( (i1 == i1));
-        assert( (i1 == i2));
-        assert(!(i1 == i3));
-        assert(!(i1 == i4));
-        assert(!(i1 == i5));
 
-        assert( (i2 == i1));
-        assert( (i2 == i2));
-        assert(!(i2 == i3));
-        assert(!(i2 == i4));
-        assert(!(i2 == i5));
 
-        assert(!(i3 == i1));
-        assert(!(i3 == i2));
-        assert( (i3 == i3));
-        assert( (i3 == i4));
-        assert( (i3 == i5));
 
-        assert(!(i4 == i1));
-        assert(!(i4 == i2));
-        assert( (i4 == i3));
-        assert( (i4 == i4));
-        assert( (i4 == i5));
 
-        assert(!(i5 == i1));
-        assert(!(i5 == i2));
-        assert( (i5 == i3));
-        assert( (i5 == i4));
-        assert( (i5 == i5));
-    }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }