From c761bbc285398c5e76bc21a5650c9a23bcbd23c4 Mon Sep 17 00:00:00 2001 From: Glen Fernandes Date: Tue, 17 Dec 2019 20:07:12 -0500 Subject: [PATCH] Clean up ios_state unit tests --- include/boost/io_fwd.hpp | 94 ++-- test/ios_state_test.cpp | 393 ++++++---------- test/ios_state_unit_test.cpp | 865 +++++++++++++---------------------- 3 files changed, 518 insertions(+), 834 deletions(-) diff --git a/include/boost/io_fwd.hpp b/include/boost/io_fwd.hpp index 417b81e..2594d4e 100644 --- a/include/boost/io_fwd.hpp +++ b/include/boost/io_fwd.hpp @@ -1,67 +1,63 @@ -// Boost io_fwd.hpp header file --------------------------------------------// - -// Copyright 2002 Daryle Walker. Use, modification, and distribution are subject -// to the Boost Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or a copy at .) - -// See for the library's home page. +/* +Copyright 2002 Daryle Walker +Distributed under the Boost Software License, Version 1.0. +(http://www.boost.org/LICENSE_1_0.txt) +*/ #ifndef BOOST_IO_FWD_HPP #define BOOST_IO_FWD_HPP -#include // for std::char_traits (declaration) +#include - -namespace boost -{ -namespace io -{ - - -// From -------------------------------------------// +namespace boost { +namespace io { class ios_flags_saver; class ios_precision_saver; class ios_width_saver; class ios_base_all_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_iostate_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_exception_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_tie_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_rdbuf_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_fill_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_locale_saver; -template < typename Ch, class Tr = ::std::char_traits > - class basic_ios_all_saver; +template > +class basic_ios_iostate_saver; -typedef basic_ios_iostate_saver ios_iostate_saver; -typedef basic_ios_iostate_saver wios_iostate_saver; -typedef basic_ios_exception_saver ios_exception_saver; -typedef basic_ios_exception_saver wios_exception_saver; -typedef basic_ios_tie_saver ios_tie_saver; -typedef basic_ios_tie_saver wios_tie_saver; -typedef basic_ios_rdbuf_saver ios_rdbuf_saver; -typedef basic_ios_rdbuf_saver wios_rdbuf_saver; -typedef basic_ios_fill_saver ios_fill_saver; -typedef basic_ios_fill_saver wios_fill_saver; -typedef basic_ios_locale_saver ios_locale_saver; -typedef basic_ios_locale_saver wios_locale_saver; -typedef basic_ios_all_saver ios_all_saver; -typedef basic_ios_all_saver wios_all_saver; +template > +class basic_ios_exception_saver; + +template > +class basic_ios_tie_saver; + +template > +class basic_ios_rdbuf_saver; + +template > +class basic_ios_fill_saver; + +template > +class basic_ios_locale_saver; + +template > +class basic_ios_all_saver; + +typedef basic_ios_iostate_saver ios_iostate_saver; +typedef basic_ios_iostate_saver wios_iostate_saver; +typedef basic_ios_exception_saver ios_exception_saver; +typedef basic_ios_exception_saver wios_exception_saver; +typedef basic_ios_tie_saver ios_tie_saver; +typedef basic_ios_tie_saver wios_tie_saver; +typedef basic_ios_rdbuf_saver ios_rdbuf_saver; +typedef basic_ios_rdbuf_saver wios_rdbuf_saver; +typedef basic_ios_fill_saver ios_fill_saver; +typedef basic_ios_fill_saver wios_fill_saver; +typedef basic_ios_locale_saver ios_locale_saver; +typedef basic_ios_locale_saver wios_locale_saver; +typedef basic_ios_all_saver ios_all_saver; +typedef basic_ios_all_saver wios_all_saver; class ios_iword_saver; class ios_pword_saver; class ios_all_word_saver; +} /* io */ +} /* boost */ -} // namespace io -} // namespace boost - - -#endif // BOOST_IO_FWD_HPP +#endif diff --git a/test/ios_state_test.cpp b/test/ios_state_test.cpp index 4e35c51..6a8c52e 100644 --- a/test/ios_state_test.cpp +++ b/test/ios_state_test.cpp @@ -1,264 +1,171 @@ -// Boost ios_state_test.cpp test file --------------------------------------// +/* +Copyright 2002, 2003 Daryle Walker -// Copyright 2002, 2003 Daryle Walker. Use, modification, and distribution are -// subject to the Boost Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or a copy at .) +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) -// Copyright 2019 Glen Joseph Fernandes -// (glenjofe@gmail.com) - -// See for the library's home page. - -// Revision History -// 15 Jun 2003 Adjust to changes in Boost.Test (Daryle Walker) -// 26 Feb 2002 Initial version (Daryle Walker) - -#include +Distributed under the Boost Software License, Version 1.0. +(http://www.boost.org/LICENSE_1_0.txt) +*/ +#include #include - -#include // for boost::io::ios_flags_saver, etc. - -#include // for std::size_t -#include // for std::setw -#include // for std::ios_base, std::streamsize, etc. -#include // for std::cout, etc. -#include // for std::istream -#include // for std::numpunct, std::locale -#include // for std::endl, std::ostream -#include // for std::streambuf -#include // for std::string +#include +#include +#include +#include +#include +#include +#include #if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) #include #endif +#include +#include +#include -// Facet with the bool names spelled backwards class backward_bool_names - : public std::numpunct -{ - typedef std::numpunct base_type; + : public std::numpunct { + typedef std::numpunct base_type; public: - explicit backward_bool_names( std::size_t refs = 0 ) - : base_type( refs ) - {} + explicit backward_bool_names(std::size_t refs = 0) + : base_type( refs ) { } protected: - virtual ~backward_bool_names() {} + ~backward_bool_names() { } - virtual base_type::string_type do_truename() const - { return "eurt"; } - virtual base_type::string_type do_falsename() const - { return "eslaf"; } + base_type::string_type do_truename() const { + return "eurt"; + } + + base_type::string_type do_falsename() const { + return "eslaf"; + } }; +void saver_tests_1(int index, + std::istream& input, + std::ostream& output, + std::ostream& err) +{ + boost::io::ios_flags_saver ifls(output); + boost::io::ios_precision_saver iprs(output); + boost::io::ios_width_saver iws(output); + boost::io::ios_tie_saver its(input); + boost::io::ios_rdbuf_saver irs(output); + boost::io::ios_fill_saver ifis(output); + boost::io::ios_locale_saver ils(output); + boost::io::ios_iword_saver iis(output, index); + boost::io::ios_pword_saver ipws(output, index); + std::locale loc(std::locale::classic(), new backward_bool_names); + input.tie(&err); + output.rdbuf(err.rdbuf()); + output.iword(index) = 69L; + output.pword(index) = &err; + output.setf(std::ios_base::showpos | std::ios_base::boolalpha); + output.setf(std::ios_base::internal, std::ios_base::adjustfield); + output.fill('@'); + output.precision( 9 ); + output << "Hello world"; + output << std::setw(10) << -16; + output << std::setw(15) << 34.5678901234; + output.imbue(loc); + output << true; + BOOST_TEST(&err == output.pword(index)); + BOOST_TEST(69L == output.iword(index)); + try { + boost::io::ios_exception_saver ies(output); + boost::io::ios_iostate_saver iis(output); + output.exceptions(std::ios_base::eofbit | std::ios_base::badbit); + output.setstate(std::ios_base::eofbit); + BOOST_ERROR("previous line should have thrown"); +#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) + } catch (std::exception&) { +#else + } catch (std::ios_base::failure&) { +#endif + BOOST_TEST(output.exceptions() == std::ios_base::goodbit ); + } +} -// Index to test custom storage -int const my_index = std::ios_base::xalloc(); +void saver_tests_2(int index, + std::istream& input, + std::ostream& output, + std::ostream& err) +{ + boost::io::ios_tie_saver its(input, &err); + boost::io::ios_rdbuf_saver irs(output, err.rdbuf()); + boost::io::ios_iword_saver iis(output, index, 69L); + boost::io::ios_pword_saver ipws(output, index, &err); + boost::io::ios_flags_saver ifls(output, + (output.flags() & ~std::ios_base::adjustfield) | + std::ios_base::showpos | + std::ios_base::boolalpha | + (std::ios_base::internal & std::ios_base::adjustfield)); + boost::io::ios_precision_saver iprs(output, 9); + boost::io::ios_fill_saver ifis(output, '@'); + output << "Hello world"; + boost::io::ios_width_saver iws(output, 12); + output << -16 + 34.5678901234; + std::locale loc(std::locale::classic(), new backward_bool_names); + boost::io::ios_locale_saver ils(output, loc); + output << true; + BOOST_TEST(&err == output.pword(index)); + BOOST_TEST(69L == output.iword(index)); + try { + boost::io::ios_exception_saver ies(output, std::ios_base::eofbit); + boost::io::ios_iostate_saver iis(output, + output.rdstate() | std::ios_base::eofbit ); + BOOST_ERROR("previous line should have thrown"); +#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) + } catch (std::exception&) { +#else + } catch (std::ios_base::failure&) { +#endif + BOOST_TEST(output.exceptions() == std::ios_base::goodbit); + } +} -// Test data -char const test_string[] = "Hello world"; -int const test_num1 = -16; -double const test_num2 = 34.5678901234; -bool const test_bool = true; - - -// Function prototypes -void saver_tests_1( std::istream &input, std::ostream &output, - std::ostream &err ); -void saver_tests_2( std::istream &input, std::ostream &output, - std::ostream &err ); - - -// Test program int main() { - using std::cout; - using std::ios_base; - using std::streamsize; - using std::cin; - - cout << "The original data is:\n"; - cout << '\t' << test_string << '\n'; - cout << '\t' << test_num1 << '\n'; - cout << '\t' << test_num2 << '\n'; - cout << '\t' << std::boolalpha << test_bool << std::endl; - - // Save states for comparison later - ios_base::fmtflags const cout_flags = cout.flags(); - streamsize const cout_precision = cout.precision(); - streamsize const cout_width = cout.width(); - ios_base::iostate const cout_iostate = cout.rdstate(); - ios_base::iostate const cout_exceptions = cout.exceptions(); - std::ostream * const cin_tie = cin.tie(); - std::streambuf * const cout_sb = cout.rdbuf(); - char const cout_fill = cout.fill(); - std::locale const cout_locale = cout.getloc(); - - cout.iword( my_index ) = 42L; - cout.pword( my_index ) = &cin; - - // Run saver tests with changing separate from saving - saver_tests_1( cin, cout, std::cerr ); - - // Check if states are back to normal - BOOST_TEST( &cin == cout.pword(my_index) ); - BOOST_TEST( 42L == cout.iword(my_index) ); - BOOST_TEST( cout_locale == cout.getloc() ); - BOOST_TEST( cout_fill == cout.fill() ); - BOOST_TEST( cout_sb == cout.rdbuf() ); - BOOST_TEST( cin_tie == cin.tie() ); - BOOST_TEST( cout_exceptions == cout.exceptions() ); - BOOST_TEST( cout_iostate == cout.rdstate() ); - BOOST_TEST( cout_width == cout.width() ); - BOOST_TEST( cout_precision == cout.precision() ); - BOOST_TEST( cout_flags == cout.flags() ); - - // Run saver tests with combined saving and changing - saver_tests_2( cin, cout, std::cerr ); - - // Check if states are back to normal - BOOST_TEST( &cin == cout.pword(my_index) ); - BOOST_TEST( 42L == cout.iword(my_index) ); - BOOST_TEST( cout_locale == cout.getloc() ); - BOOST_TEST( cout_fill == cout.fill() ); - BOOST_TEST( cout_sb == cout.rdbuf() ); - BOOST_TEST( cin_tie == cin.tie() ); - BOOST_TEST( cout_exceptions == cout.exceptions() ); - BOOST_TEST( cout_iostate == cout.rdstate() ); - BOOST_TEST( cout_width == cout.width() ); - BOOST_TEST( cout_precision == cout.precision() ); - BOOST_TEST( cout_flags == cout.flags() ); - + int index = std::ios_base::xalloc(); + std::ostringstream out; + std::ostringstream err; + std::istringstream in; + std::ios_base::fmtflags out_flags = out.flags(); + std::streamsize out_precision = out.precision(); + std::streamsize out_width = out.width(); + std::ios_base::iostate out_iostate = out.rdstate(); + std::ios_base::iostate out_exceptions = out.exceptions(); + std::ostream* in_tie = in.tie(); + std::streambuf* out_sb = out.rdbuf(); + char out_fill = out.fill(); + std::locale out_locale = out.getloc(); + out.iword(index) = 42L; + out.pword(index) = ∈ + saver_tests_1(index, in, out, err); + BOOST_TEST(&in == out.pword(index)); + BOOST_TEST(42L == out.iword(index)); + BOOST_TEST(out_locale == out.getloc()); + BOOST_TEST(out_fill == out.fill()); + BOOST_TEST(out_sb == out.rdbuf()); + BOOST_TEST(in_tie == in.tie()); + BOOST_TEST(out_exceptions == out.exceptions()); + BOOST_TEST(out_iostate == out.rdstate()); + BOOST_TEST(out_width == out.width()); + BOOST_TEST(out_precision == out.precision()); + BOOST_TEST(out_flags == out.flags()); + saver_tests_2(index, in, out, err); + BOOST_TEST(&in == out.pword(index)); + BOOST_TEST(42L == out.iword(index)); + BOOST_TEST(out_locale == out.getloc()); + BOOST_TEST(out_fill == out.fill()); + BOOST_TEST(out_sb == out.rdbuf()); + BOOST_TEST(in_tie == in.tie()); + BOOST_TEST(out_exceptions == out.exceptions()); + BOOST_TEST(out_iostate == out.rdstate()); + BOOST_TEST(out_width == out.width()); + BOOST_TEST(out_precision == out.precision()); + BOOST_TEST(out_flags == out.flags()); return boost::report_errors(); } - -// Save, change, and restore stream properties -void -saver_tests_1 -( - std::istream & input, - std::ostream & output, - std::ostream & err -) -{ - using std::locale; - using std::ios_base; - using std::setw; - - boost::io::ios_flags_saver const ifls( output ); - boost::io::ios_precision_saver const iprs( output ); - boost::io::ios_width_saver const iws( output ); - boost::io::ios_tie_saver const its( input ); - boost::io::ios_rdbuf_saver const irs( output ); - boost::io::ios_fill_saver const ifis( output ); - boost::io::ios_locale_saver const ils( output ); - boost::io::ios_iword_saver const iis( output, my_index ); - boost::io::ios_pword_saver const ipws( output, my_index ); - - locale loc( locale::classic(), new backward_bool_names ); - - input.tie( &err ); - output.rdbuf( err.rdbuf() ); - output.iword( my_index ) = 69L; - output.pword( my_index ) = &err; - - output << "The data is (again):\n"; - output.setf( ios_base::showpos | ios_base::boolalpha ); - output.setf( ios_base::internal, ios_base::adjustfield ); - output.fill( '@' ); - output.precision( 9 ); - output << '\t' << test_string << '\n'; - output << '\t' << setw( 10 ) << test_num1 << '\n'; - output << '\t' << setw( 15 ) << test_num2 << '\n'; - output.imbue( loc ); - output << '\t' << test_bool << '\n'; - - BOOST_TEST( &err == output.pword(my_index) ); - BOOST_TEST( 69L == output.iword(my_index) ); - - try - { - boost::io::ios_exception_saver const ies( output ); - boost::io::ios_iostate_saver const iis( output ); - - output.exceptions( ios_base::eofbit | ios_base::badbit ); - output.setstate( ios_base::eofbit ); - BOOST_ERROR( "previous line should have thrown" ); - } -#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) - catch ( std::exception &f ) -#else - catch ( ios_base::failure &f ) -#endif - { - err << "Got the expected I/O failure: \"" << f.what() << "\".\n"; - BOOST_TEST( output.exceptions() == ios_base::goodbit ); - } - catch ( ... ) - { - err << "Got an unknown error when doing exception test!\n"; - throw; - } -} - -// Save & change and restore stream properties -void -saver_tests_2 -( - std::istream & input, - std::ostream & output, - std::ostream & err -) -{ - using std::locale; - using std::ios_base; - - boost::io::ios_tie_saver const its( input, &err ); - boost::io::ios_rdbuf_saver const irs( output, err.rdbuf() ); - boost::io::ios_iword_saver const iis( output, my_index, 69L ); - boost::io::ios_pword_saver const ipws( output, my_index, &err ); - output << "The data is (a third time; adding the numbers):\n"; - - boost::io::ios_flags_saver const ifls( output, (output.flags() - & ~ios_base::adjustfield) | ios_base::showpos | ios_base::boolalpha - | (ios_base::internal & ios_base::adjustfield) ); - boost::io::ios_precision_saver const iprs( output, 9 ); - boost::io::ios_fill_saver const ifis( output, '@' ); - output << '\t' << test_string << '\n'; - - boost::io::ios_width_saver const iws( output, 12 ); - output.put( '\t' ); - output << test_num1 + test_num2; - output.put( '\n' ); - - locale loc( locale::classic(), - new backward_bool_names ); - boost::io::ios_locale_saver const ils( output, loc ); - output << '\t' << test_bool << '\n'; - - BOOST_TEST( &err == output.pword(my_index) ); - BOOST_TEST( 69L == output.iword(my_index) ); - - try - { - boost::io::ios_exception_saver const ies( output, ios_base::eofbit ); - boost::io::ios_iostate_saver const iis( output, output.rdstate() - | ios_base::eofbit ); - - BOOST_ERROR( "previous line should have thrown" ); - } -#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) - catch ( std::exception &f ) -#else - catch ( ios_base::failure &f ) -#endif - { - err << "Got the expected I/O failure: \"" << f.what() << "\".\n"; - BOOST_TEST( output.exceptions() == ios_base::goodbit ); - } - catch ( ... ) - { - err << "Got an unknown error when doing exception test!\n"; - throw; - } -} diff --git a/test/ios_state_unit_test.cpp b/test/ios_state_unit_test.cpp index 7dee6c7..39d6423 100644 --- a/test/ios_state_unit_test.cpp +++ b/test/ios_state_unit_test.cpp @@ -1,680 +1,461 @@ -// Boost ios_state_unit_test.cpp test file ---------------------------------// +/* +Copyright 2003 Daryle Walker -// Copyright 2003 Daryle Walker. Use, modification, and distribution are -// subject to the Boost Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or a copy at .) +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) -// Copyright 2019 Glen Joseph Fernandes -// (glenjofe@gmail.com) - -// See for the library's home page. - -// Revision History -// 12 Sep 2003 Initial version (Daryle Walker) - -#include -#include // for boost::io::ios_flags_saver, etc. +Distributed under the Boost Software License, Version 1.0. +(http://www.boost.org/LICENSE_1_0.txt) +*/ +#include #include - -#include // for NULL -#include // for std::setiosflags, etc. -#include // for std::ios_base -#include // for std::cout, std::cerr, etc. -#include // for std::iostream -#include // for std::locale, std::numpunct -#include // for std::stringstream, etc. +#include +#include +#include +#include +#include +#include #if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) #include #endif +#include +#include - -// Global constants -int const word_index = std::ios_base::xalloc(); - - -// Facet with the (classic) bool names spelled backwards class backward_bool_names - : public std::numpunct -{ - typedef std::numpunct base_type; + : public std::numpunct { + typedef std::numpunct base_type; public: - explicit backward_bool_names( std::size_t refs = 0 ) - : base_type( refs ) - {} + explicit backward_bool_names(std::size_t refs = 0) + : base_type(refs) { } protected: - virtual ~backward_bool_names() {} + ~backward_bool_names() { } - virtual base_type::string_type do_truename() const - { return "eurt"; } - virtual base_type::string_type do_falsename() const - { return "eslaf"; } + base_type::string_type do_truename() const { + return "eurt"; + } + + base_type::string_type do_falsename() const { + return "eslaf"; + } }; - -// Unit test for format-flag saving void -ios_flags_saver_unit_test -( -) +ios_flags_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - + std::stringstream ss; + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); { - boost::io::ios_flags_saver ifs( ss ); - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - - ss << noskipws << fixed << boolalpha; - BOOST_TEST_EQ( (ios_base::boolalpha | ios_base::dec - | ios_base::fixed), ss.flags() ); + boost::io::ios_flags_saver ifs(ss); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + ss << std::noskipws << std::fixed << std::boolalpha; + BOOST_TEST_EQ(std::ios_base::boolalpha | + std::ios_base::dec | + std::ios_base::fixed, ss.flags()); } - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); { - boost::io::ios_flags_saver ifs( ss, (ios_base::showbase - | ios_base::internal) ); - - BOOST_TEST_EQ( (ios_base::showbase | ios_base::internal), - ss.flags() ); - - ss << setiosflags( ios_base::unitbuf ); - BOOST_TEST_EQ( (ios_base::showbase | ios_base::internal - | ios_base::unitbuf), ss.flags() ); + boost::io::ios_flags_saver ifs(ss, + std::ios_base::showbase | std::ios_base::internal); + BOOST_TEST_EQ(std::ios_base::showbase | + std::ios_base::internal, ss.flags()); + ss << std::setiosflags(std::ios_base::unitbuf); + BOOST_TEST_EQ(std::ios_base::showbase | + std::ios_base::internal | + std::ios_base::unitbuf, ss.flags()); } - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); } -// Unit test for precision saving void -ios_precision_saver_unit_test -( -) +ios_precision_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( 6, ss.precision() ); - + std::stringstream ss; + BOOST_TEST_EQ(6, ss.precision()); { - boost::io::ios_precision_saver ips( ss ); - - BOOST_TEST_EQ( 6, ss.precision() ); - - ss << setprecision( 4 ); - BOOST_TEST_EQ( 4, ss.precision() ); + boost::io::ios_precision_saver ips(ss); + BOOST_TEST_EQ(6, ss.precision()); + ss << std::setprecision(4); + BOOST_TEST_EQ(4, ss.precision()); } - - BOOST_TEST_EQ( 6, ss.precision() ); - + BOOST_TEST_EQ(6, ss.precision()); { - boost::io::ios_precision_saver ips( ss, 8 ); - - BOOST_TEST_EQ( 8, ss.precision() ); - - ss << setprecision( 10 ); - BOOST_TEST_EQ( 10, ss.precision() ); + boost::io::ios_precision_saver ips(ss, 8); + BOOST_TEST_EQ(8, ss.precision()); + ss << std::setprecision(10); + BOOST_TEST_EQ(10, ss.precision()); } - - BOOST_TEST_EQ( 6, ss.precision() ); + BOOST_TEST_EQ(6, ss.precision()); } -// Unit test for width saving void -ios_width_saver_unit_test -( -) +ios_width_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( 0, ss.width() ); - + std::stringstream ss; + BOOST_TEST_EQ(0, ss.width()); { - boost::io::ios_width_saver iws( ss ); - - BOOST_TEST_EQ( 0, ss.width() ); - - ss << setw( 4 ); - BOOST_TEST_EQ( 4, ss.width() ); + boost::io::ios_width_saver iws(ss); + BOOST_TEST_EQ(0, ss.width()); + ss << std::setw(4); + BOOST_TEST_EQ(4, ss.width()); } - - BOOST_TEST_EQ( 0, ss.width() ); - + BOOST_TEST_EQ(0, ss.width()); { - boost::io::ios_width_saver iws( ss, 8 ); - - BOOST_TEST_EQ( 8, ss.width() ); - - ss << setw( 10 ); - BOOST_TEST_EQ( 10, ss.width() ); + boost::io::ios_width_saver iws(ss, 8); + BOOST_TEST_EQ(8, ss.width()); + ss << std::setw(10); + BOOST_TEST_EQ(10, ss.width()); } - - BOOST_TEST_EQ( 0, ss.width() ); + BOOST_TEST_EQ(0, ss.width()); } -// Unit test for I/O-state saving void -ios_iostate_saver_unit_test -( -) +ios_iostate_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - + std::stringstream ss; + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); { - boost::io::ios_iostate_saver iis( ss ); - char c; - - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - + boost::io::ios_iostate_saver iis(ss); + char c; + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); ss >> c; - BOOST_TEST_EQ( (ios_base::eofbit | ios_base::failbit), - ss.rdstate() ); - BOOST_TEST( ss.eof() ); - BOOST_TEST( ss.fail() ); - BOOST_TEST( !ss.bad() ); + BOOST_TEST_EQ(std::ios_base::eofbit | std::ios_base::failbit, + ss.rdstate()); + BOOST_TEST(ss.eof()); + BOOST_TEST(ss.fail()); + BOOST_TEST(!ss.bad()); } - - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); { - boost::io::ios_iostate_saver iis( ss, ios_base::eofbit ); - - BOOST_TEST_EQ( ios_base::eofbit, ss.rdstate() ); - BOOST_TEST( ss.eof() ); - - ss.setstate( ios_base::badbit ); - BOOST_TEST_EQ( (ios_base::eofbit | ios_base::badbit), - ss.rdstate() ); - BOOST_TEST( ss.eof() ); - BOOST_TEST( ss.fail() ); - BOOST_TEST( ss.bad() ); + boost::io::ios_iostate_saver iis(ss, std::ios_base::eofbit); + BOOST_TEST_EQ(std::ios_base::eofbit, ss.rdstate()); + BOOST_TEST(ss.eof()); + ss.setstate(std::ios_base::badbit); + BOOST_TEST_EQ(std::ios_base::eofbit | std::ios_base::badbit, + ss.rdstate()); + BOOST_TEST(ss.eof()); + BOOST_TEST(ss.fail()); + BOOST_TEST(ss.bad()); } - - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); } -// Unit test for exception-flag saving void -ios_exception_saver_unit_test -( -) +ios_exception_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - + std::stringstream ss; + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); { - boost::io::ios_exception_saver ies( ss ); - - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - - ss.exceptions( ios_base::failbit ); - BOOST_TEST_EQ( ios_base::failbit, ss.exceptions() ); - + boost::io::ios_exception_saver ies(ss); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); + ss.exceptions(std::ios_base::failbit); + BOOST_TEST_EQ(std::ios_base::failbit, ss.exceptions()); { - boost::io::ios_iostate_saver iis( ss ); - ss.exceptions( ios_base::failbit | ios_base::badbit ); - char c; - + boost::io::ios_iostate_saver iis(ss); + ss.exceptions(std::ios_base::failbit | std::ios_base::badbit); + char c; #if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) - BOOST_TEST_THROWS( ss >> c, std::exception ); + BOOST_TEST_THROWS(ss >> c, std::exception); #else - BOOST_TEST_THROWS( ss >> c, std::ios_base::failure ); + BOOST_TEST_THROWS(ss >> c, std::ios_base::failure); #endif } } - - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); { - boost::io::ios_exception_saver ies( ss, ios_base::eofbit ); - - BOOST_TEST_EQ( ios_base::eofbit, ss.exceptions() ); - - ss.exceptions( ios_base::badbit ); - BOOST_TEST_EQ( ios_base::badbit, ss.exceptions() ); - + boost::io::ios_exception_saver ies(ss, std::ios_base::eofbit); + BOOST_TEST_EQ(std::ios_base::eofbit, ss.exceptions()); + ss.exceptions(std::ios_base::badbit); + BOOST_TEST_EQ(std::ios_base::badbit, ss.exceptions()); { - boost::io::ios_iostate_saver iis( ss ); - char c; - - BOOST_TEST_NOT( ss >> c ); + boost::io::ios_iostate_saver iis(ss); + char c; + BOOST_TEST_NOT(ss >> c); } } - - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); } -// Unit test for tied-stream saving void -ios_tie_saver_unit_test -( -) +ios_tie_saver_unit_test(int index) { - using namespace std; - - BOOST_TEST( NULL == cout.tie() ); - + BOOST_TEST(NULL == std::cout.tie()); { - boost::io::ios_tie_saver its( cout ); - - BOOST_TEST( NULL == cout.tie() ); - - cout.tie( &clog ); - BOOST_TEST_EQ( &clog, cout.tie() ); + boost::io::ios_tie_saver its(std::cout); + BOOST_TEST(NULL == std::cout.tie()); + std::cout.tie(&std::clog); + BOOST_TEST_EQ(&std::clog, std::cout.tie()); } - - BOOST_TEST( NULL == cout.tie() ); - + BOOST_TEST(NULL == std::cout.tie()); { - boost::io::ios_tie_saver its( cout, &clog ); - - BOOST_TEST_EQ( &clog, cout.tie() ); - - cout.tie( &cerr ); - BOOST_TEST_EQ( &cerr, cout.tie() ); + boost::io::ios_tie_saver its(std::cout, &std::clog); + BOOST_TEST_EQ(&std::clog, std::cout.tie()); + std::cout.tie(&std::cerr); + BOOST_TEST_EQ(&std::cerr, std::cout.tie()); } - - BOOST_TEST( NULL == cout.tie() ); + BOOST_TEST(NULL == std::cout.tie()); } -// Unit test for connected-streambuf saving void -ios_rdbuf_saver_unit_test -( -) +ios_rdbuf_saver_unit_test(int index) { - using namespace std; - - iostream s( NULL ); - - BOOST_TEST( NULL == s.rdbuf() ); - + std::iostream s(NULL); + BOOST_TEST(NULL == s.rdbuf()); { - stringbuf sb; - boost::io::ios_rdbuf_saver irs( s ); - - BOOST_TEST( NULL == s.rdbuf() ); - - s.rdbuf( &sb ); - BOOST_TEST_EQ( &sb, s.rdbuf() ); + std::stringbuf sb; + boost::io::ios_rdbuf_saver irs(s); + BOOST_TEST(NULL == s.rdbuf()); + s.rdbuf(&sb); + BOOST_TEST_EQ(&sb, s.rdbuf()); } - - BOOST_TEST( NULL == s.rdbuf() ); - + BOOST_TEST(NULL == s.rdbuf()); { - stringbuf sb1, sb2( "Hi there" ); - boost::io::ios_rdbuf_saver irs( s, &sb1 ); - - BOOST_TEST_EQ( &sb1, s.rdbuf() ); - - s.rdbuf( &sb2 ); - BOOST_TEST_EQ( &sb2, s.rdbuf() ); + std::stringbuf sb1, sb2("Hi there"); + boost::io::ios_rdbuf_saver irs(s, &sb1); + BOOST_TEST_EQ(&sb1, s.rdbuf()); + s.rdbuf(&sb2); + BOOST_TEST_EQ(&sb2, s.rdbuf()); } - - BOOST_TEST( NULL == s.rdbuf() ); + BOOST_TEST(NULL == s.rdbuf()); } -// Unit test for fill-character saving void -ios_fill_saver_unit_test -( -) +ios_fill_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( ' ', ss.fill() ); - + std::stringstream ss; + BOOST_TEST_EQ(' ', ss.fill()); { - boost::io::ios_fill_saver ifs( ss ); - - BOOST_TEST_EQ( ' ', ss.fill() ); - - ss.fill( 'x' ); - BOOST_TEST_EQ( 'x', ss.fill() ); + boost::io::ios_fill_saver ifs(ss); + BOOST_TEST_EQ(' ', ss.fill()); + ss.fill('x'); + BOOST_TEST_EQ('x', ss.fill()); } - - BOOST_TEST_EQ( ' ', ss.fill() ); - + BOOST_TEST_EQ(' ', ss.fill()); { - boost::io::ios_fill_saver ifs( ss, '3' ); - - BOOST_TEST_EQ( '3', ss.fill() ); - - ss.fill( '+' ); - BOOST_TEST_EQ( '+', ss.fill() ); + boost::io::ios_fill_saver ifs(ss, '3'); + BOOST_TEST_EQ('3', ss.fill()); + ss.fill('+'); + BOOST_TEST_EQ('+', ss.fill()); } - - BOOST_TEST_EQ( ' ', ss.fill() ); + BOOST_TEST_EQ(' ', ss.fill()); } -// Unit test for locale saving void -ios_locale_saver_unit_test -( -) +ios_locale_saver_unit_test(int index) { - using namespace std; - - typedef numpunct npc_type; - - stringstream ss; - - BOOST_TEST( locale() == ss.getloc() ); - // locales are unprintable, so no BOOST_TEST_EQ - BOOST_TEST( !has_facet(ss.getloc()) || (NULL - == dynamic_cast( - &use_facet(ss.getloc()) )) ); - // my implementation of has_facet just checks IDs, but doesn't do dynamic - // cast (therefore if a specifc facet type is missing, but its base class - // is available, has_facet will mistakenly[?] match), so I have to do it - // here. I wanted: "BOOST_TEST( ! has_facet< backward_bool_names >( - // ss.getloc() ) )" + typedef std::numpunct npc_type; + std::stringstream ss; + BOOST_TEST(std::locale() == ss.getloc()); + BOOST_TEST(!std::has_facet(ss.getloc()) || + !dynamic_cast(& + std::use_facet(ss.getloc()))); { - boost::io::ios_locale_saver ils( ss ); - - BOOST_TEST( locale() == ss.getloc() ); - - ss.imbue( locale::classic() ); - BOOST_TEST( locale::classic() == ss.getloc() ); + boost::io::ios_locale_saver ils(ss); + BOOST_TEST(std::locale() == ss.getloc()); + ss.imbue(std::locale::classic()); + BOOST_TEST(std::locale::classic() == ss.getloc()); } - - BOOST_TEST( locale() == ss.getloc() ); - BOOST_TEST( !has_facet(ss.getloc()) || (NULL - == dynamic_cast( - &use_facet(ss.getloc()) )) ); - + BOOST_TEST(std::locale() == ss.getloc()); + BOOST_TEST(!std::has_facet(ss.getloc()) || + !dynamic_cast(& + std::use_facet(ss.getloc()))); { - boost::io::ios_locale_saver ils( ss, locale::classic() ); - - BOOST_TEST( locale::classic() == ss.getloc() ); - BOOST_TEST( !has_facet(ss.getloc()) || (NULL - == dynamic_cast( - &use_facet(ss.getloc()) )) ); - - ss.imbue( locale(locale::classic(), new backward_bool_names) ); - BOOST_TEST( locale::classic() != ss.getloc() ); - BOOST_TEST( has_facet(ss.getloc()) && (NULL - != dynamic_cast( - &use_facet(ss.getloc()) )) ); - //BOOST_TEST( has_facet(ss.getloc()) ); + boost::io::ios_locale_saver ils(ss, std::locale::classic()); + BOOST_TEST(std::locale::classic() == ss.getloc()); + BOOST_TEST(!std::has_facet(ss.getloc()) || + !dynamic_cast(& + std::use_facet(ss.getloc()))); + ss.imbue(std::locale(std::locale::classic(), new backward_bool_names)); + BOOST_TEST(std::locale::classic() != ss.getloc()); + BOOST_TEST(std::has_facet(ss.getloc()) && + dynamic_cast(& + std::use_facet(ss.getloc()))); } - - BOOST_TEST( locale() == ss.getloc() ); - BOOST_TEST( !has_facet(ss.getloc()) || (NULL - == dynamic_cast( - &use_facet(ss.getloc()) )) ); + BOOST_TEST(std::locale() == ss.getloc()); + BOOST_TEST(!std::has_facet(ss.getloc()) || + !dynamic_cast(& + std::use_facet(ss.getloc()))); } -// Unit test for user-defined integer data saving void -ios_iword_saver_unit_test -( -) +ios_iword_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - + std::stringstream ss; + BOOST_TEST_EQ(0, ss.iword(index)); { - boost::io::ios_iword_saver iis( ss, word_index ); - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - - ss.iword( word_index ) = 6; - BOOST_TEST_EQ( 6, ss.iword(word_index) ); + boost::io::ios_iword_saver iis(ss, index); + BOOST_TEST_EQ(0, ss.iword(index)); + ss.iword(index) = 6; + BOOST_TEST_EQ(6, ss.iword(index)); } - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - + BOOST_TEST_EQ(0, ss.iword(index)); { - boost::io::ios_iword_saver iis( ss, word_index, 100 ); - - BOOST_TEST_EQ( 100, ss.iword(word_index) ); - - ss.iword( word_index ) = -2000; - BOOST_TEST_EQ( -2000, ss.iword(word_index) ); + boost::io::ios_iword_saver iis(ss, index, 100); + BOOST_TEST_EQ(100, ss.iword(index)); + ss.iword(index) = -2000; + BOOST_TEST_EQ(-2000, ss.iword(index)); } - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); + BOOST_TEST_EQ(0, ss.iword(index)); } -// Unit test for user-defined pointer data saving void -ios_pword_saver_unit_test -( -) +ios_pword_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST( NULL == ss.pword(word_index) ); - + std::stringstream ss; + BOOST_TEST(NULL == ss.pword(index)); { - boost::io::ios_pword_saver ips( ss, word_index ); - - BOOST_TEST( NULL == ss.pword(word_index) ); - - ss.pword( word_index ) = &ss; - BOOST_TEST_EQ( &ss, ss.pword(word_index) ); + boost::io::ios_pword_saver ips(ss, index); + BOOST_TEST(NULL == ss.pword(index)); + ss.pword(index) = &ss; + BOOST_TEST_EQ(&ss, ss.pword(index)); } - - BOOST_TEST( NULL == ss.pword(word_index) ); - + BOOST_TEST(NULL == ss.pword(index)); { - boost::io::ios_pword_saver ips( ss, word_index, ss.rdbuf() ); - - BOOST_TEST_EQ( ss.rdbuf(), ss.pword(word_index) ); - - ss.pword( word_index ) = &ss; - BOOST_TEST_EQ( &ss, ss.pword(word_index) ); + boost::io::ios_pword_saver ips(ss, index, ss.rdbuf()); + BOOST_TEST_EQ(ss.rdbuf(), ss.pword(index)); + ss.pword(index) = &ss; + BOOST_TEST_EQ(&ss, ss.pword(index)); } - - BOOST_TEST( NULL == ss.pword(word_index) ); + BOOST_TEST(NULL == ss.pword(index)); } -// Unit test for all ios_base data saving void -ios_base_all_saver_unit_test -( -) +ios_base_all_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); - + std::stringstream ss; + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); { - boost::io::ios_base_all_saver ibas( ss ); - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); - - ss << hex << unitbuf << setprecision( 5 ) << setw( 7 ); - BOOST_TEST_EQ( (ios_base::unitbuf | ios_base::hex - | ios_base::skipws), ss.flags() ); - BOOST_TEST_EQ( 5, ss.precision() ); - BOOST_TEST_EQ( 7, ss.width() ); + boost::io::ios_base_all_saver ibas(ss); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); + ss << std::hex << std::unitbuf << std::setprecision(5) << std::setw(7); + BOOST_TEST_EQ(std::ios_base::unitbuf | + std::ios_base::hex | + std::ios_base::skipws, ss.flags()); + BOOST_TEST_EQ(5, ss.precision()); + BOOST_TEST_EQ(7, ss.width()); } - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); } -// Unit test for all basic_ios data saving void -ios_all_saver_unit_test -( -) +ios_all_saver_unit_test(int index) { - using namespace std; - - typedef numpunct npc_type; - - stringbuf sb; - iostream ss( &sb ); - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - BOOST_TEST( NULL == ss.tie() ); - BOOST_TEST( &sb == ss.rdbuf() ); - BOOST_TEST_EQ( ' ', ss.fill() ); - BOOST_TEST( locale() == ss.getloc() ); - + typedef std::numpunct npc_type; + std::stringbuf sb; + std::iostream ss(&sb); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); + BOOST_TEST(NULL == ss.tie()); + BOOST_TEST(&sb == ss.rdbuf()); + BOOST_TEST_EQ(' ', ss.fill()); + BOOST_TEST(std::locale() == ss.getloc()); { - boost::io::ios_all_saver ias( ss ); - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - BOOST_TEST( NULL == ss.tie() ); - BOOST_TEST( &sb == ss.rdbuf() ); - BOOST_TEST_EQ( ' ', ss.fill() ); - BOOST_TEST( locale() == ss.getloc() ); - - ss << oct << showpos << noskipws; - BOOST_TEST_EQ( (ios_base::showpos | ios_base::oct), ss.flags() ); - - ss << setprecision( 3 ); - BOOST_TEST_EQ( 3, ss.precision() ); - - ss << setw( 9 ); - BOOST_TEST_EQ( 9, ss.width() ); - - ss.setstate( ios_base::eofbit ); - BOOST_TEST_EQ( ios_base::eofbit, ss.rdstate() ); - BOOST_TEST( ss.eof() ); - - ss.exceptions( ios_base::failbit ); - BOOST_TEST_EQ( ios_base::failbit, ss.exceptions() ); - + boost::io::ios_all_saver ias(ss); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); + BOOST_TEST(NULL == ss.tie()); + BOOST_TEST(&sb == ss.rdbuf()); + BOOST_TEST_EQ(' ', ss.fill()); + BOOST_TEST(std::locale() == ss.getloc()); + ss << std::oct << std::showpos << std::noskipws; + BOOST_TEST_EQ(std::ios_base::showpos | std::ios_base::oct, ss.flags()); + ss << std::setprecision(3); + BOOST_TEST_EQ(3, ss.precision()); + ss << std::setw(9); + BOOST_TEST_EQ(9, ss.width()); + ss.setstate(std::ios_base::eofbit); + BOOST_TEST_EQ(std::ios_base::eofbit, ss.rdstate()); + BOOST_TEST(ss.eof()); + ss.exceptions(std::ios_base::failbit); + BOOST_TEST_EQ(std::ios_base::failbit, ss.exceptions()); { - boost::io::ios_iostate_saver iis( ss ); - ss.exceptions( ios_base::failbit | ios_base::badbit ); - char c; - + boost::io::ios_iostate_saver iis(ss); + ss.exceptions(std::ios_base::failbit | std::ios_base::badbit); + char c; #if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB)) - BOOST_TEST_THROWS( ss >> c, std::exception ); + BOOST_TEST_THROWS(ss >> c, std::exception); #else - BOOST_TEST_THROWS( ss >> c, std::ios_base::failure ); + BOOST_TEST_THROWS(ss >> c, std::ios_base::failure); #endif } - - ss.tie( &clog ); - BOOST_TEST_EQ( &clog, ss.tie() ); - - ss.rdbuf( cerr.rdbuf() ); - BOOST_TEST_EQ( cerr.rdbuf(), ss.rdbuf() ); - - ss << setfill( 'x' ); - BOOST_TEST_EQ( 'x', ss.fill() ); - - ss.imbue( locale(locale::classic(), new backward_bool_names) ); - BOOST_TEST( locale() != ss.getloc() ); - BOOST_TEST( has_facet(ss.getloc()) && (NULL - != dynamic_cast( - &use_facet(ss.getloc()) )) ); + ss.tie(&std::clog); + BOOST_TEST_EQ(&std::clog, ss.tie()); + ss.rdbuf(std::cerr.rdbuf()); + BOOST_TEST_EQ(std::cerr.rdbuf(), ss.rdbuf()); + ss << std::setfill('x'); + BOOST_TEST_EQ('x', ss.fill()); + ss.imbue(std::locale(std::locale::classic(), new backward_bool_names)); + BOOST_TEST(std::locale() != ss.getloc()); + BOOST_TEST(std::has_facet(ss.getloc()) && + dynamic_cast(& + std::use_facet(ss.getloc()))); } - - BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() ); - BOOST_TEST_EQ( 6, ss.precision() ); - BOOST_TEST_EQ( 0, ss.width() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() ); - BOOST_TEST( ss.good() ); - BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() ); - BOOST_TEST( NULL == ss.tie() ); - BOOST_TEST( &sb == ss.rdbuf() ); - BOOST_TEST_EQ( ' ', ss.fill() ); - BOOST_TEST( locale() == ss.getloc() ); + BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags()); + BOOST_TEST_EQ(6, ss.precision()); + BOOST_TEST_EQ(0, ss.width()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate()); + BOOST_TEST(ss.good()); + BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions()); + BOOST_TEST(NULL == ss.tie()); + BOOST_TEST(&sb == ss.rdbuf()); + BOOST_TEST_EQ(' ', ss.fill()); + BOOST_TEST(std::locale() == ss.getloc()); } -// Unit test for user-defined data saving void -ios_word_saver_unit_test -( -) +ios_word_saver_unit_test(int index) { - using namespace std; - - stringstream ss; - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - BOOST_TEST( NULL == ss.pword(word_index) ); - + std::stringstream ss; + BOOST_TEST_EQ(0, ss.iword(index)); + BOOST_TEST(NULL == ss.pword(index)); { - boost::io::ios_all_word_saver iaws( ss, word_index ); - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - BOOST_TEST( NULL == ss.pword(word_index) ); - - ss.iword( word_index ) = -11; - ss.pword( word_index ) = ss.rdbuf(); - BOOST_TEST_EQ( -11, ss.iword(word_index) ); - BOOST_TEST_EQ( ss.rdbuf(), ss.pword(word_index) ); + boost::io::ios_all_word_saver iaws(ss, index); + BOOST_TEST_EQ(0, ss.iword(index)); + BOOST_TEST(NULL == ss.pword(index)); + ss.iword(index) = -11; + ss.pword(index) = ss.rdbuf(); + BOOST_TEST_EQ(-11, ss.iword(index)); + BOOST_TEST_EQ(ss.rdbuf(), ss.pword(index)); } - - BOOST_TEST_EQ( 0, ss.iword(word_index) ); - BOOST_TEST( NULL == ss.pword(word_index) ); + BOOST_TEST_EQ(0, ss.iword(index)); + BOOST_TEST(NULL == ss.pword(index)); } - -// Unit test program int main() { - ios_flags_saver_unit_test(); - ios_precision_saver_unit_test(); - ios_width_saver_unit_test(); - - ios_iostate_saver_unit_test(); - ios_exception_saver_unit_test(); - ios_tie_saver_unit_test(); - ios_rdbuf_saver_unit_test(); - ios_fill_saver_unit_test(); - ios_locale_saver_unit_test(); - - ios_iword_saver_unit_test(); - ios_pword_saver_unit_test(); - - ios_base_all_saver_unit_test(); - ios_all_saver_unit_test(); - ios_word_saver_unit_test(); - + int index = std::ios_base::xalloc(); + ios_flags_saver_unit_test(index); + ios_precision_saver_unit_test(index); + ios_width_saver_unit_test(index); + ios_iostate_saver_unit_test(index); + ios_exception_saver_unit_test(index); + ios_tie_saver_unit_test(index); + ios_rdbuf_saver_unit_test(index); + ios_fill_saver_unit_test(index); + ios_locale_saver_unit_test(index); + ios_iword_saver_unit_test(index); + ios_pword_saver_unit_test(index); + ios_base_all_saver_unit_test(index); + ios_all_saver_unit_test(index); + ios_word_saver_unit_test(index); return boost::report_errors(); }