This is an archive of the discontinued LLVM Phabricator instance.

Differential D49863

[istream] Fix error flags and exceptions propagated from input stream operations
ClosedPublic

Authored by ldionne on Jul 26 2018, 9:25 AM.

Details

Reviewers
mclow.lists
EricWF
lichray
Commits
rCXX357775: [libc++] Fix error flags and exceptions propagated from input stream operations
rG396145d0da19: [libc++] Fix error flags and exceptions propagated from input stream operations
rL357775: [libc++] Fix error flags and exceptions propagated from input stream operations
rG1754774369ac: [libc++] Fix error flags and exceptions propagated from input stream operations
rCXX357531: [libc++] Fix error flags and exceptions propagated from input stream operations
rL357531: [libc++] Fix error flags and exceptions propagated from input stream operations
Summary

Before this patch, we would only ever throw an exception if the badbit
was set on the stream. The Standard is currently very unclear on how
exceptions should be propagated and what error flags should be set by
the input stream operations. This commit changes libc++ to behave under
a different (but valid) interpretation of the Standard. This interpretation
of the Standard matches what other implementations are doing.

I will submit a paper in San Diego to clarify the Standard such that the
interpretation used in this commit (and other implementations) is the only
possible one.

https://bugs.llvm.org/show_bug.cgi?id=21586
https://bugs.llvm.org/show_bug.cgi?id=15949
rdar://problem/15347558

Diff Detail

Repository
rL LLVM

Event Timeline

ldionne created this revision.Jul 26 2018, 9:25 AM
Herald added subscribers: cfe-commits, dexonsmith, christof. · View Herald TranscriptJul 26 2018, 9:25 AM
Harbormaster completed remote builds in B20738: Diff 157506.Jul 26 2018, 9:25 AM
ldionne added a comment.Jul 26 2018, 9:37 AM

This is a very tricky change since it touches all the input stream operations, both formatted and unformatted. However, I think it's an important change as it fixes extremely broken behavior. The paper I'm working on to fix this in the Standard is https://github.com/ldionne/wg21/blob/4d963b488182b96479636c252695542671fd5e41/generated/drxxxx.pdf. Perhaps we should wait for the paper to make its way through the Standard before committing this, but in any case the new behavior of libc++ should now match that of libstdc++ and MSVC (couldn't test with those libraries, though).

lichray accepted this revision.Nov 8 2018, 11:20 AM
lichray added a subscriber: lichray.
lichray added inline comments.
libcxx/include/istream
365 ↗(On Diff #157506)

I like auto just FYI :)

1005 ↗(On Diff #157506)

LOL

This revision is now accepted and ready to land.Nov 8 2018, 11:20 AM
Herald added a subscriber: libcxx-commits. · View Herald TranscriptNov 8 2018, 11:20 AM
ldionne added a comment.Feb 11 2019, 1:05 PM

I would like to merge this even though http://wg21.link/p1264 has not been voted into C++ yet, because this is arguably a bug and libc++ differs from other stdlibs in this regard. Once http://wg21.link/p1264 is merged into C++ in one way of another, libc++ will simply have nothing to do.

@mclow.lists Are you OK with that?

Herald added a subscriber: jkorous. · View Herald TranscriptFeb 11 2019, 1:05 PM
ldionne updated this revision to Diff 193342.Apr 2 2019, 12:27 PM

Rebase on top of master.

Herald added a project: Restricted Project. · View Herald TranscriptApr 2 2019, 12:27 PM
Harbormaster completed remote builds in B29958: Diff 193342.Apr 2 2019, 12:28 PM
mclow.lists accepted this revision.Apr 2 2019, 1:28 PM

I'm OK with this. I think, strictly speaking, that libc++ is following the standard, and everyone else is not - but what everyone else is doing makes sense.

libcxx/include/istream
365 ↗(On Diff #157506)

You may like auto, but C++03 does not.

Closed by commit rL357531: [libc++] Fix error flags and exceptions propagated from input stream operations (authored by ldionne). · Explain WhyApr 2 2019, 2:43 PM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptApr 2 2019, 2:43 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
aprantl added a subscriber: aprantl.Apr 2 2019, 3:08 PM

It looks like this may have broken some LLDB data formatters:
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_optional/TestDataFormatterLibcxxOptional_py/
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_unordered/TestDataFormatterUnordered_py/

ldionne reopened this revision.Apr 2 2019, 3:22 PM
In D49863#1452126, @aprantl wrote:

It looks like this may have broken some LLDB data formatters:
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_optional/TestDataFormatterLibcxxOptional_py/
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_unordered/TestDataFormatterUnordered_py/

I reverted in r357536 to give some time to figure what the problem is.

This revision is now accepted and ready to land.Apr 2 2019, 3:22 PM
ldionne updated this revision to Diff 193900.Apr 5 2019, 9:28 AM

Rebase on top of master.

Harbormaster completed remote builds in B30109: Diff 193900.Apr 5 2019, 9:28 AM
ldionne added a comment.Apr 5 2019, 9:30 AM
In D49863#1452154, @ldionne wrote:
In D49863#1452126, @aprantl wrote:

It looks like this may have broken some LLDB data formatters:
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_optional/TestDataFormatterLibcxxOptional_py/
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/22934/testReport/junit/lldb-Suite/functionalities_data-formatter_data-formatter-stl_libcxx_unordered/TestDataFormatterUnordered_py/

I reverted in r357536 to give some time to figure what the problem is.

It turns out I think only r357531 had been applied and this is what broke the LLDB CI.

Closed by commit rL357775: [libc++] Fix error flags and exceptions propagated from input stream operations (authored by ldionne). · Explain WhyApr 5 2019, 9:33 AM
This revision was automatically updated to reflect the committed changes.
w2yehia added a subscriber: w2yehia.Aug 5 2022, 3:43 PM
w2yehia added inline comments.
libcxx/trunk/include/istream
1222

Hi @ldionne, you're setting the local __state and returning, while before we calling this->setstate.
I see you added this->setstate(__state); in the bottom.
It seems this is a bug?

Herald added a project: Restricted Project. · View Herald TranscriptAug 5 2022, 3:43 PM
hubert.reinterpretcast added a subscriber: hubert.reinterpretcast.Aug 6 2022, 9:33 AM
hubert.reinterpretcast added inline comments.
libcxx/trunk/include/istream
1223

@ldionne, another dubious aspect of this patch is that it initializes __r to 0 and never sets it. Seems like this line should have been to set __r and not to return directly.

Revision Contents

PathSize
libcxx/
trunk/
include/
9 lines
883 lines
test/
std/
input.output/
iostream.format/
input.streams/
istream.formatted/
istream.formatted.arithmetic/
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
41 lines
istream_extractors/
77 lines
41 lines
43 lines
104 lines
41 lines
43 lines
81 lines
istream.manip/
39 lines
istream.unformatted/
47 lines
49 lines
93 lines
93 lines
71 lines
70 lines
93 lines
93 lines
36 lines
35 lines
36 lines
37 lines
69 lines
36 lines
strings/
basic.string/
string.nonmembers/
string.io/
82 lines
81 lines
39 lines
utilities/
template.bitset/
bitset.operators/
55 lines
4 lines

Diff 193902

libcxx/trunk/include/ios

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY bool bad() const; _LIBCPP_INLINE_VISIBILITY bool bad() const;
_LIBCPP_INLINE_VISIBILITY iostate exceptions() const; _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
_LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate); _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate);
void __set_badbit_and_consider_rethrow(); void __set_badbit_and_consider_rethrow();
void __set_failbit_and_consider_rethrow(); void __set_failbit_and_consider_rethrow();
_LIBCPP_INLINE_VISIBILITY
void __setstate_nothrow(iostate __state)
{
if (__rdbuf_)
__rdstate_ |= __state;
else
__rdstate_ |= __state | ios_base::badbit;
}
protected: protected:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
ios_base() {// purposefully does no initialization ios_base() {// purposefully does no initialization
} }
void init(void* __sb); void init(void* __sb);
_LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;} _LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;}
▲ Show 20 Lines • Show All 717 Lines • Show Last 20 Lines

libcxx/trunk/include/istream

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines
basic_istream<_CharT, _Traits>::~basic_istream() basic_istream<_CharT, _Traits>::~basic_istream()
{ {
} }
template <class _Tp, class _CharT, class _Traits> template <class _Tp, class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { __input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef num_get<_CharT, _Ip> _Fp; typedef num_get<_CharT, _Ip> _Fp;
ios_base::iostate __err = ios_base::goodbit; use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __err, __n);
__is.setstate(__err);
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
{ {
return _VSTD::__input_arithmetic<unsigned short>(*this, __n); return _VSTD::__input_arithmetic<unsigned short>(*this, __n);
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
{ {
return _VSTD::__input_arithmetic<void*>(*this, __n); return _VSTD::__input_arithmetic<void*>(*this, __n);
} }
template <class _Tp, class _CharT, class _Traits> template <class _Tp, class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { __input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s)
{
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef num_get<_CharT, _Ip> _Fp; typedef num_get<_CharT, _Ip> _Fp;
ios_base::iostate __err = ios_base::goodbit;
long __temp; long __temp;
use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __err, __temp); use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
if (__temp < numeric_limits<_Tp>::min()) if (__temp < numeric_limits<_Tp>::min())
{ {
__err |= ios_base::failbit; __state |= ios_base::failbit;
__n = numeric_limits<_Tp>::min(); __n = numeric_limits<_Tp>::min();
} }
else if (__temp > numeric_limits<_Tp>::max()) else if (__temp > numeric_limits<_Tp>::max())
{ {
__err |= ios_base::failbit; __state |= ios_base::failbit;
__n = numeric_limits<_Tp>::max(); __n = numeric_limits<_Tp>::max();
} }
else else
{
__n = static_cast<_Tp>(__temp); __n = static_cast<_Tp>(__temp);
__is.setstate(__err);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
__is.setstate(__state);
}
return __is; return __is;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::operator>>(short& __n) basic_istream<_CharT, _Traits>::operator>>(short& __n)
{ {
return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n); return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n);
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::operator>>(int& __n) basic_istream<_CharT, _Traits>::operator>>(int& __n)
{ {
return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n); return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n);
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n) __input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS ios_base::iostate __state = ios_base::goodbit;
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
_CharT* __s = __p; _CharT* __s = __p;
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
ios_base::iostate __err = ios_base::goodbit;
while (__s != __p + (__n-1)) while (__s != __p + (__n-1))
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
_CharT __ch = _Traits::to_char_type(__i); _CharT __ch = _Traits::to_char_type(__i);
if (__ct.is(__ct.space, __ch)) if (__ct.is(__ct.space, __ch))
break; break;
*__s++ = __ch; *__s++ = __ch;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
*__s = _CharT(); *__s = _CharT();
__is.width(0); __is.width(0);
if (__s == __p) if (__s == __p)
__err |= ios_base::failbit; __state |= ios_base::failbit;
__is.setstate(__err);
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template<class _CharT, class _Traits, size_t _Np> template<class _CharT, class _Traits, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS ios_base::iostate __state = ios_base::goodbit;
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
__is.setstate(ios_base::eofbit | ios_base::failbit); __state |= ios_base::eofbit | ios_base::failbit;
else else
__c = _Traits::to_char_type(__i); __c = _Traits::to_char_type(__i);
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
template<class _Traits> template<class _Traits>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<char, _Traits>& basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c) operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c)
{ {
return __is >> (char&)__c; return __is >> (char&)__c;
} }
template<class _Traits> template<class _Traits>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<char, _Traits>& basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __is, signed char& __c) operator>>(basic_istream<char, _Traits>& __is, signed char& __c)
{ {
return __is >> (char&)__c; return __is >> (char&)__c;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb) basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
sentry __s(*this, true); sentry __s(*this, true);
if (__s) if (__s)
{ {
if (__sb) if (__sb)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
ios_base::iostate __err = ios_base::goodbit;
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, _Traits::eof())) if (traits_type::eq_int_type(__i, _Traits::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
if (traits_type::eq_int_type( if (traits_type::eq_int_type(
__sb->sputc(traits_type::to_char_type(__i)), __sb->sputc(traits_type::to_char_type(__i)),
traits_type::eof())) traits_type::eof()))
break; break;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
if (__gc_ == 0) if (__gc_ == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
this->setstate(__err);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit;
if (__gc_ == 0) if (__gc_ == 0)
this->__set_failbit_and_consider_rethrow(); __state |= ios_base::failbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
} }
else else
this->setstate(ios_base::failbit);
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::failbit;
}
this->setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::int_type typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::get() basic_istream<_CharT, _Traits>::get()
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
int_type __r = traits_type::eof(); int_type __r = traits_type::eof();
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
sentry __s(*this, true); sentry __s(*this, true);
if (__s) if (__s)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
__r = this->rdbuf()->sbumpc(); __r = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__r, traits_type::eof())) if (traits_type::eq_int_type(__r, traits_type::eof()))
this->setstate(ios_base::failbit | ios_base::eofbit); __state |= ios_base::failbit | ios_base::eofbit;
else else
__gc_ = 1; __gc_ = 1;
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__setstate_nothrow(this->rdstate() | ios_base::badbit);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
this->setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm) basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
if (__n > 0) if (__n > 0)
{ {
ios_base::iostate __err = ios_base::goodbit; #ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
while (__gc_ < __n-1) while (__gc_ < __n-1)
{ {
int_type __i = this->rdbuf()->sgetc(); int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
break; break;
*__s++ = __ch; *__s++ = __ch;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
if (__gc_ == 0) if (__gc_ == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
this->setstate(__err); #ifndef _LIBCPP_NO_EXCEPTIONS
}
else
this->setstate(ios_base::failbit);
} }
catch (...)
{
__state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
if (__n > 0) if (__n > 0)
*__s = char_type(); *__s = char_type();
#ifndef _LIBCPP_NO_EXCEPTIONS throw;
} }
catch (...) }
#endif
}
else
{ {
__state |= ios_base::failbit;
}
if (__n > 0) if (__n > 0)
*__s = char_type(); *__s = char_type();
this->__set_badbit_and_consider_rethrow(); this->setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS if (__n > 0)
*__s = char_type();
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb, basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
char_type __dlm) char_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
ios_base::iostate __err = ios_base::goodbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
break; break;
if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof())) if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
break; break;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit;
// according to the spec, exceptions here are caught but not rethrown
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
if (__gc_ == 0) if (__gc_ == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
this->setstate(__err); this->setstate(__state);
}
#ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
ios_base::iostate __err = ios_base::goodbit;
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
{ {
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
++__gc_; ++__gc_;
break; break;
} }
if (__gc_ >= __n-1) if (__gc_ >= __n-1)
{ {
__err |= ios_base::failbit; __state |= ios_base::failbit;
break; break;
} }
*__s++ = __ch; *__s++ = __ch;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
++__gc_; ++__gc_;
} }
if (__gc_ == 0)
__err |= ios_base::failbit;
this->setstate(__err);
}
if (__n > 0)
*__s = char_type();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
if (__n > 0) if (__n > 0)
*__s = char_type(); *__s = char_type();
this->__set_badbit_and_consider_rethrow(); if (__gc_ == 0)
__state |= ios_base::failbit;
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
}
if (__n > 0)
*__s = char_type();
if (__gc_ == 0)
__state |= ios_base::failbit;
this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
ios_base::iostate __err = ios_base::goodbit;
if (__n == numeric_limits<streamsize>::max()) if (__n == numeric_limits<streamsize>::max())
{ {
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sbumpc(); typename traits_type::int_type __i = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
++__gc_; ++__gc_;
if (traits_type::eq_int_type(__i, __dlm)) if (traits_type::eq_int_type(__i, __dlm))
break; break;
} }
} }
else else
{ {
while (__gc_ < __n) while (__gc_ < __n)
{ {
typename traits_type::int_type __i = this->rdbuf()->sbumpc(); typename traits_type::int_type __i = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
++__gc_; ++__gc_;
if (traits_type::eq_int_type(__i, __dlm)) if (traits_type::eq_int_type(__i, __dlm))
break; break;
} }
} }
this->setstate(__err);
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::int_type typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::peek() basic_istream<_CharT, _Traits>::peek()
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
int_type __r = traits_type::eof(); int_type __r = traits_type::eof();
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
__r = this->rdbuf()->sgetc(); __r = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__r, traits_type::eof())) if (traits_type::eq_int_type(__r, traits_type::eof()))
this->setstate(ios_base::eofbit); __state |= ios_base::eofbit;
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
__gc_ = this->rdbuf()->sgetn(__s, __n); __gc_ = this->rdbuf()->sgetn(__s, __n);
if (__gc_ != __n) if (__gc_ != __n)
this->setstate(ios_base::failbit | ios_base::eofbit); __state |= ios_base::failbit | ios_base::eofbit;
}
else
this->setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
}
else
{
__state |= ios_base::failbit;
}
this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
streamsize streamsize
basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
{ {
ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
streamsize __c = this->rdbuf()->in_avail(); streamsize __c = this->rdbuf()->in_avail();
switch (__c) switch (__c)
{ {
case -1: case -1:
this->setstate(ios_base::eofbit); __state |= ios_base::eofbit;
break; break;
case 0: case 0:
break; break;
default: default:
read(__s, _VSTD::min(__c, __n)); __n = _VSTD::min(__c, __n);
__gc_ = this->rdbuf()->sgetn(__s, __n);
if (__gc_ != __n)
__state |= ios_base::failbit | ios_base::eofbit;
break; break;
} }
}
else
this->setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
}
else
{
__state |= ios_base::failbit;
}
this->setstate(__state);
return __gc_; return __gc_;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::putback(char_type __c) basic_istream<_CharT, _Traits>::putback(char_type __c)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
__gc_ = 0; __gc_ = 0;
this->clear(__state);
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __sen(*this, true);
if (__sen)
{
if (this->rdbuf() == 0 || this->rdbuf()->sputbackc(__c) == traits_type::eof()) if (this->rdbuf() == 0 || this->rdbuf()->sputbackc(__c) == traits_type::eof())
this->setstate(ios_base::badbit); __state |= ios_base::badbit;
}
else
this->setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
}
else
{
__state |= ios_base::failbit;
}
this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::unget() basic_istream<_CharT, _Traits>::unget()
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
__gc_ = 0; __gc_ = 0;
this->clear(__state);
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __sen(*this, true);
if (__sen)
{
if (this->rdbuf() == 0 || this->rdbuf()->sungetc() == traits_type::eof()) if (this->rdbuf() == 0 || this->rdbuf()->sungetc() == traits_type::eof())
this->setstate(ios_base::badbit); __state |= ios_base::badbit;
}
else
this->setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
}
else
{
__state |= ios_base::failbit;
}
this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
int int
basic_istream<_CharT, _Traits>::sync() basic_istream<_CharT, _Traits>::sync()
{ {
ios_base::iostate __state = ios_base::goodbit;
int __r = 0; int __r = 0;
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
{
if (this->rdbuf() == 0) if (this->rdbuf() == 0)
return -1; return -1;
if (this->rdbuf()->pubsync() == -1) if (this->rdbuf()->pubsync() == -1)
{ {
this->setstate(ios_base::badbit); __state |= ios_base::badbit;
w2yehiaUnsubmitted
Not Done
ReplyInline Actions

Hi @ldionne, you're setting the local __state and returning, while before we calling this->setstate.
I see you added this->setstate(__state); in the bottom.
It seems this is a bug?

w2yehia: Hi @ldionne, you're setting the local __state and returning, while before we calling this…
return -1; return -1;
hubert.reinterpretcastUnsubmitted
Not Done
ReplyInline Actions
__state |= ios_base::badbit;
- return -1;
+ __r = -1;
}
#ifndef _LIBCPP_NO_EXCEPTIONS

@ldionne, another dubious aspect of this patch is that it initializes __r to 0 and never sets it. Seems like this line should have been to set __r and not to return directly.

hubert.reinterpretcast: @ldionne, another dubious aspect of this patch is that it initializes `__r` to `0` and never…
} }
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::pos_type typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::tellg() basic_istream<_CharT, _Traits>::tellg()
{ {
ios_base::iostate __state = ios_base::goodbit;
pos_type __r(-1); pos_type __r(-1);
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
sentry __sen(*this, true);
if (__sen)
__r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::seekg(pos_type __pos) basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
this->clear(__state);
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __sen(*this, true);
if (__sen)
{
if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1)) if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
this->setstate(ios_base::failbit); __state |= ios_base::failbit;
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
this->clear(__state);
sentry __sen(*this, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->clear(this->rdstate() & ~ios_base::eofbit);
sentry __sen(*this, true);
if (__sen)
{
if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1)) if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
this->setstate(ios_base::failbit); __state |= ios_base::failbit;
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
this->setstate(__state);
}
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is) ws(basic_istream<_CharT, _Traits>& __is)
{ {
ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen)
{
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen)
{
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
while (true) while (true)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__is.setstate(ios_base::eofbit); __state |= ios_base::eofbit;
break; break;
} }
if (!__ct.is(__ct.space, _Traits::to_char_type(__i))) if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
break; break;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_NO_EXCEPTIONS
__is.setstate(__state);
}
return __is; return __is;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, class _Tp> template <class _CharT, class _Traits, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
{ {
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str) basic_string<_CharT, _Traits, _Allocator>& __str)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS ios_base::iostate __state = ios_base::goodbit;
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
__str.clear(); __str.clear();
streamsize __n = __is.width(); streamsize __n = __is.width();
if (__n <= 0) if (__n <= 0)
__n = __str.max_size(); __n = __str.max_size();
if (__n <= 0) if (__n <= 0)
__n = numeric_limits<streamsize>::max(); __n = numeric_limits<streamsize>::max();
streamsize __c = 0; streamsize __c = 0;
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
ios_base::iostate __err = ios_base::goodbit;
while (__c < __n) while (__c < __n)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
_CharT __ch = _Traits::to_char_type(__i); _CharT __ch = _Traits::to_char_type(__i);
if (__ct.is(__ct.space, __ch)) if (__ct.is(__ct.space, __ch))
break; break;
__str.push_back(__ch); __str.push_back(__ch);
++__c; ++__c;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
__is.width(0); __is.width(0);
if (__c == 0) if (__c == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
__is.setstate(__err);
}
else
__is.setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is, getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS ios_base::iostate __state = ios_base::goodbit;
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
__str.clear(); __str.clear();
ios_base::iostate __err = ios_base::goodbit;
streamsize __extr = 0; streamsize __extr = 0;
while (true) while (true)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
++__extr; ++__extr;
_CharT __ch = _Traits::to_char_type(__i); _CharT __ch = _Traits::to_char_type(__i);
if (_Traits::eq(__ch, __dlm)) if (_Traits::eq(__ch, __dlm))
break; break;
__str.push_back(__ch); __str.push_back(__ch);
if (__str.size() == __str.max_size()) if (__str.size() == __str.max_size())
{ {
__err |= ios_base::failbit; __state |= ios_base::failbit;
break; break;
} }
} }
if (__extr == 0) if (__extr == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
__is.setstate(__err);
}
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is, getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str) basic_string<_CharT, _Traits, _Allocator>& __str)
Show All 22 Lines
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _CharT, class _Traits, size_t _Size> template <class _CharT, class _Traits, size_t _Size>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS ios_base::iostate __state = ios_base::goodbit;
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif
basic_string<_CharT, _Traits> __str; basic_string<_CharT, _Traits> __str;
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
size_t __c = 0; size_t __c = 0;
ios_base::iostate __err = ios_base::goodbit;
_CharT __zero = __ct.widen('0'); _CharT __zero = __ct.widen('0');
_CharT __one = __ct.widen('1'); _CharT __one = __ct.widen('1');
while (__c < _Size) while (__c < _Size)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__err |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
_CharT __ch = _Traits::to_char_type(__i); _CharT __ch = _Traits::to_char_type(__i);
if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
break; break;
__str.push_back(__ch); __str.push_back(__ch);
++__c; ++__c;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
__x = bitset<_Size>(__str); __x = bitset<_Size>(__str);
if (__c == 0) if (__c == 0)
__err |= ios_base::failbit; __state |= ios_base::failbit;
__is.setstate(__err);
}
else
__is.setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __state |= ios_base::badbit;
__is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit)
{
throw;
}
}
#endif
__is.setstate(__state);
} }
#endif // _LIBCPP_NO_EXCEPTIONS
return __is; return __is;
} }
#ifndef _LIBCPP_DO_NOT_ASSUME_STREAMS_EXPLICIT_INSTANTIATION_IN_DYLIB #ifndef _LIBCPP_DO_NOT_ASSUME_STREAMS_EXPLICIT_INSTANTIATION_IN_DYLIB
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<char>) _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<char>)
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>) _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>)
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>) _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>)
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_ISTREAM #endif // _LIBCPP_ISTREAM

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(bool& val); // operator>>(bool& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" 1 "); testbuf<wchar_t> sb(L" 1 ");
std::wistream is(&sb); std::wistream is(&sb);
bool n = 0; bool n = 0;
is >> n; is >> n;
assert(n == true); assert(n == true);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
bool n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
bool n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(double& val); // operator>>(double& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -123.5 "); testbuf<wchar_t> sb(L" -123.5 ");
std::wistream is(&sb); std::wistream is(&sb);
double n = 10; double n = 10;
is >> n; is >> n;
assert(n == -123.5); assert(n == -123.5);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
double n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
double n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(float& val); // operator>>(float& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -123.5 "); testbuf<wchar_t> sb(L" -123.5 ");
std::wistream is(&sb); std::wistream is(&sb);
float n = 10; float n = 10;
is >> n; is >> n;
assert(n == -123.5); assert(n == -123.5);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
float n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
float n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp

Show All 10 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(int& val); // operator>>(int& val);
#include <istream> #include <istream>
#include <limits> #include <limits>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -1234567890123456 "); testbuf<wchar_t> sb(L" -1234567890123456 ");
std::wistream is(&sb); std::wistream is(&sb);
int n = 10; int n = 10;
is >> n; is >> n;
assert(n == std::numeric_limits<int>::min()); assert(n == std::numeric_limits<int>::min());
assert(!is.eof()); assert(!is.eof());
assert( is.fail()); assert( is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
int n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
int n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(long& val); // operator>>(long& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -123 "); testbuf<wchar_t> sb(L" -123 ");
std::wistream is(&sb); std::wistream is(&sb);
long n = 10; long n = 10;
is >> n; is >> n;
assert(n == -123); assert(n == -123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(long double& val); // operator>>(long double& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -123.5 "); testbuf<wchar_t> sb(L" -123.5 ");
std::wistream is(&sb); std::wistream is(&sb);
long double n = 10; long double n = 10;
is >> n; is >> n;
assert(n == -123.5); assert(n == -123.5);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
long double n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
long double n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(long long& val); // operator>>(long long& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -123 "); testbuf<wchar_t> sb(L" -123 ");
std::wistream is(&sb); std::wistream is(&sb);
long long n = 10; long long n = 10;
is >> n; is >> n;
assert(n == -123); assert(n == -123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
long long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
long long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp

Show All 13 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(void*& val); // operator>>(void*& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L"12345678"); testbuf<wchar_t> sb(L"12345678");
std::wistream is(&sb); std::wistream is(&sb);
void* n = 0; void* n = 0;
is >> n; is >> n;
assert(n == (void*)0x12345678); assert(n == (void*)0x12345678);
assert( is.eof()); assert( is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
void* n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
void* n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp

Show All 10 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(short& val); // operator>>(short& val);
#include <istream> #include <istream>
#include <limits> #include <limits>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" -1234567890 "); testbuf<wchar_t> sb(L" -1234567890 ");
std::wistream is(&sb); std::wistream is(&sb);
short n = 10; short n = 10;
is >> n; is >> n;
assert(n == std::numeric_limits<short>::min()); assert(n == std::numeric_limits<short>::min());
assert(!is.eof()); assert(!is.eof());
assert( is.fail()); assert( is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
short n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
short n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(unsigned int& val); // operator>>(unsigned int& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" 123 "); testbuf<wchar_t> sb(L" 123 ");
std::wistream is(&sb); std::wistream is(&sb);
unsigned int n = 10; unsigned int n = 10;
is >> n; is >> n;
assert(n == 123); assert(n == 123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned int n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned int n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(unsigned long& val); // operator>>(unsigned long& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" 123 "); testbuf<wchar_t> sb(L" 123 ");
std::wistream is(&sb); std::wistream is(&sb);
unsigned long n = 10; unsigned long n = 10;
is >> n; is >> n;
assert(n == 123); assert(n == 123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(unsigned long long& val); // operator>>(unsigned long long& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" 123 "); testbuf<wchar_t> sb(L" 123 ");
std::wistream is(&sb); std::wistream is(&sb);
unsigned long long n = 10; unsigned long long n = 10;
is >> n; is >> n;
assert(n == 123); assert(n == 123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned long long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned long long n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp

Show All 9 Lines
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// operator>>(unsigned short& val); // operator>>(unsigned short& val);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint main(int, char**)
testbuf<wchar_t> sb(L" 123 "); testbuf<wchar_t> sb(L" 123 ");
std::wistream is(&sb); std::wistream is(&sb);
unsigned short n = 10; unsigned short n = 10;
is >> n; is >> n;
assert(n == 123); assert(n == 123);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned short n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned short n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class charT, class traits> // template<class charT, class traits>
// basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, charT& c); // basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, charT& c);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint main(int, char**)
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == L'b'); assert(c == L'b');
is >> c; is >> c;
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == L'c'); assert(c == L'c');
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
wchar_t n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
wchar_t n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class traits> // template<class traits>
// basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, signed char& c); // basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, signed char& c);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
Show All 37 Linesint main(int, char**)
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == 'b'); assert(c == 'b');
is >> c; is >> c;
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == 'c'); assert(c == 'c');
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
signed char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
signed char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class traits> // template<class traits>
// basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, signed char* s); // basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, signed char* s);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines#if TEST_STD_VER > 17
std::istream is(&sb); std::istream is(&sb);
signed char s[1]; signed char s[1];
is >> s; is >> s;
assert(!is.eof()); assert(!is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string((char*)s) == ""); assert(std::string((char*)s) == "");
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
signed char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
signed char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class basic_istream; // class basic_istream;
// basic_istream<charT,traits>& operator<<(basic_streambuf<charT,traits>* sb); // basic_istream<charT,traits>& operator>>(basic_streambuf<charT,traits>* sb);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
std::basic_string<CharT> str_; std::basic_string<CharT> str_;
public: public:
testbuf() testbuf()
Show All 33 Linesint main(int, char**)
{ {
testbuf<char> sb("testing..."); testbuf<char> sb("testing...");
std::istream is(&sb); std::istream is(&sb);
testbuf<char> sb2; testbuf<char> sb2;
is >> &sb2; is >> &sb2;
assert(sb2.str() == "testing..."); assert(sb2.str() == "testing...");
assert(is.gcount() == 10); assert(is.gcount() == 10);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::istream::eofbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::istream::eofbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> static_cast<testbuf<char>*>(0);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert(!is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> static_cast<testbuf<wchar_t>*>(0);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert(!is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class traits> // template<class traits>
// basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, unsigned char& c); // basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, unsigned char& c);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
Show All 37 Linesint main(int, char**)
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == 'b'); assert(c == 'b');
is >> c; is >> c;
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == 'c'); assert(c == 'c');
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned char n = 0;
is >> n;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class traits> // template<class traits>
// basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, unsigned char* s); // basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, unsigned char* s);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines#if TEST_STD_VER > 17
std::istream is(&sb); std::istream is(&sb);
unsigned char s[1]; unsigned char s[1];
is >> s; is >> s;
assert(!is.eof()); assert(!is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string((char*)s) == ""); assert(std::string((char*)s) == "");
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
unsigned char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
unsigned char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template<class charT, class traits> // template<class charT, class traits>
// basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, charT* s); // basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, charT* s);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines#if TEST_STD_VER > 17
std::istream is(&sb); std::istream is(&sb);
char s[1]; char s[1];
is >> s; is >> s;
assert(!is.eof()); assert(!is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string(s) == ""); assert(std::string(s) == "");
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb;
std::wistream is(&sb);
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
wchar_t s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
char s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb;
std::wistream is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
wchar_t s[20];
is.width(10);
is >> s;
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// template <class charT, class traits> // template <class charT, class traits>
// basic_istream<charT,traits>& // basic_istream<charT,traits>&
// ws(basic_istream<charT,traits>& is); // ws(basic_istream<charT,traits>& is);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
std::wistream is(&sb); std::wistream is(&sb);
ws(is); ws(is);
assert(!is.fail()); assert(!is.fail());
assert(is.eof()); assert(is.eof());
ws(is); ws(is);
assert(is.eof()); assert(is.eof());
assert(is.fail()); assert(is.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
std::ws(is);
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
std::ws(is);
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// int_type get(); // int_type get();
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c == L'b'); assert(c == L'b');
assert(is.gcount() == 1); assert(is.gcount() == 1);
c = is.get(); c = is.get();
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == L'c'); assert(c == L'c');
assert(is.gcount() == 1); assert(is.gcount() == 1);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb("rrrrrrrrr");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
while (true) {
is.get();
if (is.eof())
break;
}
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb(L"rrrrrrrrr");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
while (true) {
is.get();
if (is.eof())
break;
}
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& get(char_type& c); // basic_istream<charT,traits>& get(char_type& c);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c == L'b'); assert(c == L'b');
assert(is.gcount() == 1); assert(is.gcount() == 1);
is.get(c); is.get(c);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(c == L'c'); assert(c == L'c');
assert(is.gcount() == 1); assert(is.gcount() == 1);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb("rrrrrrrrr");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
while (true) {
char c;
is.get(c);
if (is.eof())
break;
}
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
}
{
testbuf<wchar_t> sb(L"rrrrrrrrr");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
while (true) {
wchar_t c;
is.get(c);
if (is.eof())
break;
}
} catch (std::ios_base::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 1); assert(is.gcount() == 1);
// Check that even in error case the buffer is properly 0-terminated. // Check that even in error case the buffer is properly 0-terminated.
is.get(s, 5); is.get(s, 5);
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string(s) == ""); assert(std::string(s) == "");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::istream is(&sb);
char s[5] = "test";
is.exceptions(std::istream::eofbit | std::istream::badbit);
try
{
is.get(s, 5);
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert( is.eof());
assert( is.fail());
assert(std::string(s) == " ");
assert(is.gcount() == 1);
}
#endif
{ {
testbuf<wchar_t> sb(L" \n \n "); testbuf<wchar_t> sb(L" \n \n ");
std::wistream is(&sb); std::wistream is(&sb);
wchar_t s[5]; wchar_t s[5];
is.get(s, 5); is.get(s, 5);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(std::wstring(s) == L" "); assert(std::wstring(s) == L" ");
Show All 20 Linesint main(int, char**)
is.get(s, 5); is.get(s, 5);
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L""); assert(std::wstring(s) == L"");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ {
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::string(s) == " ");
assert(is.gcount() == 1);
}
{
testbuf<wchar_t> sb(L" "); testbuf<wchar_t> sb(L" ");
std::wistream is(&sb); std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test"; wchar_t s[5] = L"test";
is.exceptions(std::wistream::eofbit | std::wistream::badbit); is.exceptions(std::ios_base::eofbit);
try bool threw = false;
try {
is.get(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::wstring(s) == L" ");
assert(is.gcount() == 1);
}
{ {
testbuf<char> sb;
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
is.get(s, 5); is.get(s, 5);
assert(false); } catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert( is.fail());
assert(threw);
assert(std::basic_string<char>(s) == "");
assert(is.gcount() == 0);
} }
catch (std::ios_base::failure&)
{ {
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
is.get(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
} }
assert(!is.bad());
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L" "); assert(threw);
assert(is.gcount() == 1); assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 1); assert(is.gcount() == 1);
// Check that even in error case the buffer is properly 0-terminated. // Check that even in error case the buffer is properly 0-terminated.
is.get(s, 5, '*'); is.get(s, 5, '*');
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string(s) == ""); assert(std::string(s) == "");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::istream is(&sb);
char s[5] = "test";
is.exceptions(std::istream::eofbit | std::istream::badbit);
try
{
is.get(s, 5, '*');
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert( is.eof());
assert( is.fail());
assert(std::string(s) == " ");
assert(is.gcount() == 1);
}
#endif
{ {
testbuf<wchar_t> sb(L" * * "); testbuf<wchar_t> sb(L" * * ");
std::wistream is(&sb); std::wistream is(&sb);
wchar_t s[5]; wchar_t s[5];
is.get(s, 5, L'*'); is.get(s, 5, L'*');
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(std::wstring(s) == L" "); assert(std::wstring(s) == L" ");
Show All 20 Linesint main(int, char**)
is.get(s, 5, L'*'); is.get(s, 5, L'*');
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L""); assert(std::wstring(s) == L"");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ {
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(s, 5, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<char>(s) == " ");
assert(is.gcount() == 1);
}
{
testbuf<wchar_t> sb(L" "); testbuf<wchar_t> sb(L" ");
std::wistream is(&sb); std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test"; wchar_t s[5] = L"test";
is.exceptions(std::wistream::eofbit | std::wistream::badbit); is.exceptions(std::ios_base::eofbit);
try bool threw = false;
{ try {
is.get(s, 5, L'*'); is.get(s, 5, L'*');
assert(false); } catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert(is.gcount() == 1);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
is.get(s, 5, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert( is.fail());
assert(threw);
assert(std::basic_string<char>(s) == "");
assert(is.gcount() == 0);
} }
catch (std::ios_base::failure&)
{ {
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::failbit);
bool threw = false;
try {
is.get(s, 5, L'*');
} catch (std::ios_base::failure&) {
threw = true;
} }
assert(!is.bad());
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L" "); assert(threw);
assert(is.gcount() == 1); assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb); // basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
std::basic_string<CharT> str_; std::basic_string<CharT> str_;
public: public:
testbuf() testbuf()
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 7); assert(is.gcount() == 7);
assert(is.get() == L'\n'); assert(is.get() == L'\n');
is.get(sb2); is.get(sb2);
assert(sb2.str() == L"testing..."); assert(sb2.str() == L"testing...");
assert(is.eof()); assert(is.eof());
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 3); assert(is.gcount() == 3);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, // basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
// char_type delim); // char_type delim);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
class testbuf class testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
std::basic_string<CharT> str_; std::basic_string<CharT> str_;
public: public:
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 7); assert(is.gcount() == 7);
assert(is.get() == L'*'); assert(is.get() == L'*');
is.get(sb2, L'*'); is.get(sb2, L'*');
assert(sb2.str() == L"testing..."); assert(sb2.str() == L"testing...");
assert(is.eof()); assert(is.eof());
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 3); assert(is.gcount() == 3);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2, L'*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.get(sb2, L'*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 1); assert(is.gcount() == 1);
// Check that even in error case the buffer is properly 0-terminated. // Check that even in error case the buffer is properly 0-terminated.
is.getline(s, 5); is.getline(s, 5);
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string(s) == ""); assert(std::string(s) == "");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::istream is(&sb);
char s[5] = "test";
is.exceptions(std::istream::eofbit | std::istream::badbit);
try
{
is.getline(s, 5);
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert( is.eof());
assert( is.fail());
assert(std::string(s) == " ");
assert(is.gcount() == 1);
}
#endif
{ {
testbuf<wchar_t> sb(L" \n \n "); testbuf<wchar_t> sb(L" \n \n ");
std::wistream is(&sb); std::wistream is(&sb);
wchar_t s[5]; wchar_t s[5];
is.getline(s, 5); is.getline(s, 5);
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(std::wstring(s) == L" "); assert(std::wstring(s) == L" ");
Show All 12 Linesint main(int, char**)
is.getline(s, 5); is.getline(s, 5);
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L""); assert(std::wstring(s) == L"");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ {
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<char>(s) == " ");
assert(is.gcount() == 1);
}
{
testbuf<wchar_t> sb(L" "); testbuf<wchar_t> sb(L" ");
std::wistream is(&sb); std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test"; wchar_t s[5] = L"test";
is.exceptions(std::wistream::eofbit | std::wistream::badbit); is.exceptions(std::ios_base::eofbit);
try bool threw = false;
try {
is.getline(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert(is.gcount() == 1);
}
{ {
testbuf<char> sb;
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5); is.getline(s, 5);
assert(false); } catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert( is.fail());
assert(threw);
assert(std::basic_string<char>(s) == "");
assert(is.gcount() == 0);
} }
catch (std::ios_base::failure&)
{ {
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
} }
assert(!is.bad());
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L" "); assert(threw);
assert(is.gcount() == 1); assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 1); assert(is.gcount() == 1);
// Check that even in error case the buffer is properly 0-terminated. // Check that even in error case the buffer is properly 0-terminated.
is.getline(s, 5, '*'); is.getline(s, 5, '*');
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::string(s) == ""); assert(std::string(s) == "");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::istream is(&sb);
char s[5] = "test";
is.exceptions(std::istream::eofbit | std::istream::badbit);
try
{
is.getline(s, 5, '*');
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert( is.eof());
assert( is.fail());
assert(std::string(s) == " ");
assert(is.gcount() == 1);
}
#endif
{ {
testbuf<wchar_t> sb(L" * * "); testbuf<wchar_t> sb(L" * * ");
std::wistream is(&sb); std::wistream is(&sb);
wchar_t s[5]; wchar_t s[5];
is.getline(s, 5, L'*'); is.getline(s, 5, L'*');
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(std::wstring(s) == L" "); assert(std::wstring(s) == L" ");
Show All 12 Linesint main(int, char**)
is.getline(s, 5, L'*'); is.getline(s, 5, L'*');
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L""); assert(std::wstring(s) == L"");
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ {
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<char>(s) == " ");
assert(is.gcount() == 1);
}
{
testbuf<wchar_t> sb(L" "); testbuf<wchar_t> sb(L" ");
std::wistream is(&sb); std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test"; wchar_t s[5] = L"test";
is.exceptions(std::wistream::eofbit | std::wistream::badbit); is.exceptions(std::ios_base::eofbit);
try bool threw = false;
{ try {
is.getline(s, 5, L'*'); is.getline(s, 5, L'*');
assert(false); } catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert(is.gcount() == 1);
}
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
char s[5] = "test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5, '*');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(!is.bad());
assert( is.eof());
assert( is.fail());
assert(threw);
assert(std::basic_string<char>(s) == "");
assert(is.gcount() == 0);
} }
catch (std::ios_base::failure&)
{ {
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.getline(s, 5, L'*');
} catch (std::ios_base::failure&) {
threw = true;
} }
assert(!is.bad());
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(std::wstring(s) == L" "); assert(threw);
assert(is.gcount() == 1); assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
} }
#endif #endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& // basic_istream<charT,traits>&
// ignore(streamsize n = 1, int_type delim = traits::eof()); // ignore(streamsize n = 1, int_type delim = traits::eof());
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
string_type str_; string_type str_;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main(int, char**)
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 2); assert(is.gcount() == 2);
is.ignore(15); is.ignore(15);
assert( is.eof()); assert( is.eof());
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 6); assert(is.gcount() == 6);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.ignore(5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.ignore(5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// int_type peek(); // int_type peek();
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
Show All 37 Linesint main(int, char**)
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 0); assert(is.gcount() == 0);
is.get(); is.get();
assert(is.peek() == L'1'); assert(is.peek() == L'1');
assert(!is.eof()); assert(!is.eof());
assert(!is.fail()); assert(!is.fail());
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.peek();
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.peek();
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& putback(char_type c); // basic_istream<charT,traits>& putback(char_type c);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
string_type str_; string_type str_;
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 0); assert(is.gcount() == 0);
is.putback(L' '); is.putback(L' ');
assert(is.good()); assert(is.good());
assert(is.gcount() == 0); assert(is.gcount() == 0);
is.putback(L' '); is.putback(L' ');
assert(is.bad()); assert(is.bad());
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.putback('x');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.putback(L'x');
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& read(char_type* s, streamsize n); // basic_istream<charT,traits>& read(char_type* s, streamsize n);
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
assert(!is.fail()); assert(!is.fail());
assert(std::wstring(s, 5) == L"56789"); assert(std::wstring(s, 5) == L"56789");
assert(is.gcount() == 5); assert(is.gcount() == 5);
is.read(s, 5); is.read(s, 5);
assert( is.eof()); assert( is.eof());
assert( is.fail()); assert( is.fail());
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
char s[10];
bool threw = false;
try {
is.read(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
wchar_t s[10];
bool threw = false;
try {
is.read(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// int sync(); // int sync();
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
int sync_called = 0; int sync_called = 0;
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
Show All 17 Lines
protected: protected:
int sync() int sync()
{ {
++sync_called; ++sync_called;
return 5; return 5;
} }
}; };
#ifndef TEST_HAS_NO_EXCEPTIONS
struct testbuf_exception { };
template <class CharT>
struct throwing_testbuf
: public std::basic_streambuf<CharT>
{
typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base;
private:
string_type str_;
public:
throwing_testbuf() {}
throwing_testbuf(const string_type& str)
: str_(str)
{
base::setg(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data()) + str_.size());
}
CharT* eback() const {return base::eback();}
CharT* gptr() const {return base::gptr();}
CharT* egptr() const {return base::egptr();}
protected:
virtual int sync()
{
throw testbuf_exception();
return 5;
}
};
#endif // TEST_HAS_NO_EXCEPTIONS
int main(int, char**) int main(int, char**)
{ {
{ {
testbuf<char> sb(" 123456789"); testbuf<char> sb(" 123456789");
std::istream is(&sb); std::istream is(&sb);
assert(is.sync() == 0); assert(is.sync() == 0);
assert(sync_called == 1); assert(sync_called == 1);
} }
{ {
testbuf<wchar_t> sb(L" 123456789"); testbuf<wchar_t> sb(L" 123456789");
std::wistream is(&sb); std::wistream is(&sb);
assert(is.sync() == 0); assert(is.sync() == 0);
assert(sync_called == 2); assert(sync_called == 2);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
throwing_testbuf<char> sb(" 123456789");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.sync();
} catch (testbuf_exception const&) {
threw = true;
}
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
{
throwing_testbuf<wchar_t> sb(L" 123456789");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.sync();
} catch (testbuf_exception const&) {
threw = true;
}
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <istream> // <istream>
// basic_istream<charT,traits>& unget(); // basic_istream<charT,traits>& unget();
#include <istream> #include <istream>
#include <cassert> #include <cassert>
#include "test_macros.h"
template <class CharT> template <class CharT>
struct testbuf struct testbuf
: public std::basic_streambuf<CharT> : public std::basic_streambuf<CharT>
{ {
typedef std::basic_string<CharT> string_type; typedef std::basic_string<CharT> string_type;
typedef std::basic_streambuf<CharT> base; typedef std::basic_streambuf<CharT> base;
private: private:
string_type str_; string_type str_;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main(int, char**)
assert(is.gcount() == 0); assert(is.gcount() == 0);
is.unget(); is.unget();
assert(is.good()); assert(is.good());
assert(is.gcount() == 0); assert(is.gcount() == 0);
is.unget(); is.unget();
assert(is.bad()); assert(is.bad());
assert(is.gcount() == 0); assert(is.gcount() == 0);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.unget();
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::badbit);
bool threw = false;
try {
is.unget();
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert( is.bad());
assert(!is.eof());
assert( is.fail());
}
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp

Show All 12 Lines
// getline(basic_istream<charT,traits>& is, // getline(basic_istream<charT,traits>& is,
// basic_string<charT,traits,Allocator>& str); // basic_string<charT,traits,Allocator>& str);
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
#include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream in(" abc\n def\n ghij"); std::istringstream in(" abc\n def\n ghij");
std::string s("initial text"); std::string s("initial text");
getline(in, s); getline(in, s);
assert(in.good()); assert(in.good());
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
getline(in, s); getline(in, s);
assert(in.good()); assert(in.good());
assert(s == L" def"); assert(s == L" def");
getline(in, s); getline(in, s);
assert(in.eof()); assert(in.eof());
assert(s == L" ghij"); assert(s == L" ghij");
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::basic_stringbuf<char> sb("hello");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::eofbit);
std::basic_string<char> s;
bool threw = false;
try {
std::getline(is, s);
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
assert(s == "hello");
}
{
std::basic_stringbuf<wchar_t> sb(L"hello");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::eofbit);
std::basic_string<wchar_t> s;
bool threw = false;
try {
std::getline(is, s);
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
assert(s == L"hello");
}
{
std::basic_stringbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios_base::failbit);
std::basic_string<char> s;
bool threw = false;
try {
std::getline(is, s);
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
assert(s == "");
}
{
std::basic_stringbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios_base::failbit);
std::basic_string<wchar_t> s;
bool threw = false;
try {
std::getline(is, s);
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
assert(s == L"");
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp

Show All 12 Lines
// getline(basic_istream<charT,traits>& is, // getline(basic_istream<charT,traits>& is,
// basic_string<charT,traits,Allocator>& str, charT delim); // basic_string<charT,traits,Allocator>& str, charT delim);
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
#include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream in(" abc* def** ghij"); std::istringstream in(" abc* def** ghij");
std::string s("initial text"); std::string s("initial text");
getline(in, s, '*'); getline(in, s, '*');
assert(in.good()); assert(in.good());
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
getline(in, s, L'*'); getline(in, s, L'*');
assert(in.good()); assert(in.good());
assert(s == L""); assert(s == L"");
getline(in, s, L'*'); getline(in, s, L'*');
assert(in.eof()); assert(in.eof());
assert(s == L" ghij"); assert(s == L" ghij");
} }
#endif #endif
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::basic_stringbuf<char> sb("hello");
std::basic_istream<char> is(&sb);
is.exceptions(std::ios::eofbit);
std::basic_string<char> s;
bool threw = false;
try {
std::getline(is, s, '\n');
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
assert(s == "hello");
}
{
std::basic_stringbuf<wchar_t> sb(L"hello");
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios::eofbit);
std::basic_string<wchar_t> s;
bool threw = false;
try {
std::getline(is, s, L'\n');
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(!is.fail());
assert( is.eof());
assert(threw);
assert(s == L"hello");
}
{
std::basic_stringbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::ios::failbit);
std::basic_string<char> s;
bool threw = false;
try {
std::getline(is, s, '\n');
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
assert(s == "");
}
{
std::basic_stringbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::ios::failbit);
std::basic_string<wchar_t> s;
bool threw = false;
try {
std::getline(is, s, L'\n');
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert( is.fail());
assert( is.eof());
assert(threw);
assert(s == L"");
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp

Show All 12 Lines
// operator>>(basic_istream<charT,traits>& is, // operator>>(basic_istream<charT,traits>& is,
// basic_string<charT,traits,Allocator>& str); // basic_string<charT,traits,Allocator>& str);
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
#include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{ {
std::istringstream in("a bc defghij"); std::istringstream in("a bc defghij");
std::string s("initial text"); std::string s("initial text");
in >> s; in >> s;
assert(in.good()); assert(in.good());
Show All 31 Linesint main(int, char**)
assert(s == L"def"); assert(s == L"def");
assert(in.peek() == L'g'); assert(in.peek() == L'g');
in >> s; in >> s;
assert(in.eof()); assert(in.eof());
assert(s == L"ghij"); assert(s == L"ghij");
in >> s; in >> s;
assert(in.fail()); assert(in.fail());
} }
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::stringbuf sb;
std::istream is(&sb);
is.exceptions(std::ios::failbit);
bool threw = false;
try {
std::string s;
is >> s;
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
std::stringbuf sb;
std::istream is(&sb);
is.exceptions(std::ios::eofbit);
bool threw = false;
try {
std::string s;
is >> s;
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S; typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
std::istringstream in("a bc defghij"); std::istringstream in("a bc defghij");
S s("initial text"); S s("initial text");
in >> s; in >> s;
assert(in.good()); assert(in.good());
assert(s == "a"); assert(s == "a");
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/trunk/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// test: // test:
// template <class charT, class traits, size_t N> // template <class charT, class traits, size_t N>
// basic_ostream<charT, traits>& // basic_istream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x); // operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
#include <bitset> #include <bitset>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
{
std::istringstream in("01011010"); std::istringstream in("01011010");
std::bitset<8> b; std::bitset<8> b;
in >> b; in >> b;
assert(b.to_ulong() == 0x5A); assert(b.to_ulong() == 0x5A);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::stringbuf sb;
std::istream is(&sb);
is.exceptions(std::ios::failbit);
bool threw = false;
try {
std::bitset<8> b;
is >> b;
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
{
std::stringbuf sb;
std::istream is(&sb);
is.exceptions(std::ios::eofbit);
bool threw = false;
try {
std::bitset<8> b;
is >> b;
} catch (std::ios::failure const&) {
threw = true;
}
assert(!is.bad());
assert(is.fail());
assert(is.eof());
assert(threw);
}
#endif // TEST_HAS_NO_EXCEPTIONS
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// test: // test:
// template <class charT, class traits, size_t N> // template <class charT, class traits, size_t N>
// basic_istream<charT, traits>& // basic_ostream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, bitset<N>& x); // operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
#include <bitset> #include <bitset>
#include <sstream> #include <sstream>
#include <cassert> #include <cassert>
int main(int, char**) int main(int, char**)
{ {
std::ostringstream os; std::ostringstream os;
std::bitset<8> b(0x5A); std::bitset<8> b(0x5A);
os << b; os << b;
assert(os.str() == "01011010"); assert(os.str() == "01011010");
return 0; return 0;
} }