Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-25 02:28:18 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Revert "[libc++] Fix error flags and exceptions propagated from input stream operations"

Browse Source 
This reverts commits r357533 and r357531, which broke the LLDB
data formatters. I'll hold off until we know how to fix the data
formatters accordingly.

llvm-svn: 357536
This commit is contained in:
Louis Dionne 2019-04-02 22:21:27 +00:00
parent cc525c97b7
commit 38b7e74836
42 changed files with 547 additions and 2494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
libcxx/include/ios
View File

@ -330,15 +330,6 @@ public:
void __set_badbit_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:
_LIBCPP_INLINE_VISIBILITY
ios_base() {// purposefully does no initialization

905
libcxx/include/istream
View File

File diff suppressed because it is too large Load Diff

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -16,7 +16,6 @@
#include <istream>
#include <limits>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -77,44 +76,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -19,7 +19,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -98,44 +97,6 @@ int main(int, char**)
assert( is.eof());
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;
}

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

@ -16,7 +16,6 @@
#include <istream>
#include <limits>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -77,44 +76,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -15,7 +15,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,44 +75,6 @@ int main(int, char**)
assert(!is.eof());
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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -84,80 +83,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -67,44 +66,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -104,46 +103,6 @@ int main(int, char**)
assert(std::string((char*)s) == "");
}
#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;
}

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

@ -11,13 +11,11 @@
// template <class charT, class traits = char_traits<charT> >
// 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 <cassert>
#include "test_macros.h"
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
@ -67,104 +65,6 @@ int main(int, char**)
assert(sb2.str() == "testing...");
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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -67,44 +66,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -104,46 +103,6 @@ int main(int, char**)
assert(std::string((char*)s) == "");
}
#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;
}

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

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -115,84 +114,6 @@ int main(int, char**)
assert(std::string(s) == "");
}
#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;
}

39
libcxx/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
View File

@ -14,7 +14,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -76,42 +75,6 @@ int main(int, char**)
assert(is.eof());
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;
}

47
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
View File

@ -12,7 +12,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -97,50 +96,6 @@ int main(int, char**)
assert(c == L'c');
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;
}

49
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
View File

@ -12,7 +12,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -100,52 +99,6 @@ int main(int, char**)
assert(c == L'c');
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;
}

93
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
View File

@ -84,6 +84,26 @@ int main(int, char**)
assert(std::string(s) == "");
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 ");
std::wistream is(&sb);
@ -119,79 +139,24 @@ int main(int, char**)
assert(is.gcount() == 0);
}
#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" ");
std::basic_istream<wchar_t> is(&sb);
std::wistream is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.exceptions(std::wistream::eofbit | std::wistream::badbit);
try
{
is.get(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert( is.fail());
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);
} 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);
}
{
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.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
}
#endif
return 0;

95
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
View File

@ -84,6 +84,26 @@ int main(int, char**)
assert(std::string(s) == "");
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" * * ");
std::wistream is(&sb);
@ -119,79 +139,24 @@ int main(int, char**)
assert(is.gcount() == 0);
}
#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" ");
std::basic_istream<wchar_t> is(&sb);
std::wistream is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.exceptions(std::wistream::eofbit | std::wistream::badbit);
try
{
is.get(s, 5, L'*');
} catch (std::ios_base::failure&) {
threw = true;
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert( is.fail());
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, '*');
} 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);
}
{
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.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
}
#endif
return 0;

71
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
View File

@ -13,8 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
@ -86,73 +84,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

70
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
View File

@ -13,7 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
class testbuf
@ -86,73 +85,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

95
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
View File

@ -76,6 +76,26 @@ int main(int, char**)
assert(std::string(s) == "");
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 ");
std::wistream is(&sb);
@ -103,79 +123,24 @@ int main(int, char**)
assert(is.gcount() == 0);
}
#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" ");
std::basic_istream<wchar_t> is(&sb);
std::wistream is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.exceptions(std::wistream::eofbit | std::wistream::badbit);
try
{
is.getline(s, 5);
} catch (std::ios_base::failure&) {
threw = true;
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert( is.fail());
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::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);
}
{
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.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
}
#endif
return 0;

95
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
View File

@ -76,6 +76,26 @@ int main(int, char**)
assert(std::string(s) == "");
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" * * ");
std::wistream is(&sb);
@ -103,79 +123,24 @@ int main(int, char**)
assert(is.gcount() == 0);
}
#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" ");
std::basic_istream<wchar_t> is(&sb);
std::wistream is(&sb);
wchar_t s[5] = L"test";
is.exceptions(std::ios_base::eofbit);
bool threw = false;
try {
is.exceptions(std::wistream::eofbit | std::wistream::badbit);
try
{
is.getline(s, 5, L'*');
} catch (std::ios_base::failure&) {
threw = true;
assert(false);
}
catch (std::ios_base::failure&)
{
}
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L" ");
assert( is.fail());
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::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);
}
{
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.fail());
assert(threw);
assert(std::basic_string<wchar_t>(s) == L"");
assert(is.gcount() == 0);
}
#endif
return 0;

36
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
View File

@ -14,8 +14,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
@ -74,38 +72,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

35
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
View File

@ -12,7 +12,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -66,38 +65,6 @@ int main(int, char**)
assert(!is.fail());
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;
}

36
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
View File

@ -13,8 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
@ -87,38 +85,6 @@ int main(int, char**)
assert(is.bad());
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;
}

37
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
View File

@ -12,7 +12,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
@ -78,40 +77,6 @@ int main(int, char**)
assert( is.fail());
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;
}

69
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
View File

@ -13,8 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
int sync_called = 0;
template <class CharT>
@ -48,41 +46,6 @@ protected:
}
};
#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**)
{
{
@ -97,36 +60,6 @@ int main(int, char**)
assert(is.sync() == 0);
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;
}

36
libcxx/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
View File

@ -13,8 +13,6 @@
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
struct testbuf
: public std::basic_streambuf<CharT>
@ -79,38 +77,6 @@ int main(int, char**)
assert(is.bad());
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;
}

82
libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
View File

@ -18,7 +18,6 @@
#include <cassert>
#include "min_allocator.h"
#include "test_macros.h"
int main(int, char**)
{
@ -78,85 +77,6 @@ int main(int, char**)
assert(s == L" ghij");
}
#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;
}

81
libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
View File

@ -18,7 +18,6 @@
#include <cassert>
#include "min_allocator.h"
#include "test_macros.h"
int main(int, char**)
{
@ -90,84 +89,6 @@ int main(int, char**)
assert(s == L" ghij");
}
#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;
}

39
libcxx/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
View File

@ -18,7 +18,6 @@
#include <cassert>
#include "min_allocator.h"
#include "test_macros.h"
int main(int, char**)
{
@ -66,44 +65,6 @@ int main(int, char**)
in >> s;
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
{
typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;

55
libcxx/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
View File

@ -9,60 +9,19 @@
// test:
// template <class charT, class traits, size_t N>
// basic_istream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
#include <bitset>
#include <sstream>
#include <cassert>
#include "test_macros.h"
int main(int, char**)
{
{
std::istringstream in("01011010");
std::bitset<8> b;
in >> b;
assert(b.to_ulong() == 0x5A);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
std::stringbuf sb;
std::istream is(&sb);
is.exceptions(std::ios::failbit);
std::istringstream in("01011010");
std::bitset<8> b;
in >> b;
assert(b.to_ulong() == 0x5A);
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;
}

4
libcxx/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
View File

@ -9,8 +9,8 @@
// test:
// template <class charT, class traits, size_t N>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
// basic_istream<charT, traits>&
// operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
#include <bitset>
#include <sstream>