boostorg/io
1
0
Fork 1
mirror of https://github.com/boostorg/io.git synced 2025-07-29 20:07:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Switch to Lightweight Test for unit tests

Browse Source
This commit is contained in:
Glen Fernandes
2019-12-12 22:22:17 -05:00
parent 4255fe9abe
commit 69560d45d2
4 changed files with 226 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
test/Jamfile.v2
View File

@ -1,26 +1,13 @@
# Boost.IO Library test Jamfile
# 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
# <http://www.boost.org/LICENSE_1_0.txt>.)
# Copyright 2019 Glen Joseph Fernandes
# (glenjofe@gmail.com)
#
# See <http://www.boost.org/libs/io/> for the library's home page.
# Distributed under the Boost Software License, Version 1.0.
# (http://www.boost.org/LICENSE_1_0.txt)
test-suite "io"
: [ run ios_state_unit_test.cpp
../../../libs/test/build//boost_unit_test_framework/<link>static
: # args
: # input files
# : std::locale-support
]
import testing ;
[ run ios_state_test.cpp
../../../libs/test/build//boost_test_exec_monitor/<link>static
: # args
: # input files
# : std::locale-support
]
[ run quoted_manip_test.cpp ]
;
run ios_state_unit_test.cpp ;
run ios_state_test.cpp ;
run quoted_manip_test.cpp ;

71
test/ios_state_test.cpp
View File

@ -4,6 +4,9 @@
// subject to the Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
// Copyright 2019 Glen Joseph Fernandes
// (glenjofe@gmail.com)
// See <http://www.boost.org/libs/io/> for the library's home page.
// Revision History
@ -11,9 +14,8 @@
// 26 Feb 2002 Initial version (Daryle Walker)
#include <boost/config.hpp>
#include <boost/test/minimal.hpp> // main, BOOST_CHECK, etc.
#include <boost/core/lightweight_test.hpp>
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/io/ios_state.hpp> // for boost::io::ios_flags_saver, etc.
#include <cstddef> // for std::size_t
@ -68,12 +70,7 @@ void saver_tests_2( std::istream &input, std::ostream &output,
// Test program
int
test_main
(
int , // "argc" is unused
char * [] // "argv" is unused
)
int main()
{
using std::cout;
using std::ios_base;
@ -104,35 +101,35 @@ test_main
saver_tests_1( cin, cout, std::cerr );
// Check if states are back to normal
BOOST_CHECK( &cin == cout.pword(my_index) );
BOOST_CHECK( 42L == cout.iword(my_index) );
BOOST_CHECK( cout_locale == cout.getloc() );
BOOST_CHECK( cout_fill == cout.fill() );
BOOST_CHECK( cout_sb == cout.rdbuf() );
BOOST_CHECK( cin_tie == cin.tie() );
BOOST_CHECK( cout_exceptions == cout.exceptions() );
BOOST_CHECK( cout_iostate == cout.rdstate() );
BOOST_CHECK( cout_width == cout.width() );
BOOST_CHECK( cout_precision == cout.precision() );
BOOST_CHECK( cout_flags == cout.flags() );
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_CHECK( &cin == cout.pword(my_index) );
BOOST_CHECK( 42L == cout.iword(my_index) );
BOOST_CHECK( cout_locale == cout.getloc() );
BOOST_CHECK( cout_fill == cout.fill() );
BOOST_CHECK( cout_sb == cout.rdbuf() );
BOOST_CHECK( cin_tie == cin.tie() );
BOOST_CHECK( cout_exceptions == cout.exceptions() );
BOOST_CHECK( cout_iostate == cout.rdstate() );
BOOST_CHECK( cout_width == cout.width() );
BOOST_CHECK( cout_precision == cout.precision() );
BOOST_CHECK( cout_flags == cout.flags() );
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() );
return boost::exit_success;
return boost::report_errors();
}
// Save, change, and restore stream properties
@ -176,8 +173,8 @@ saver_tests_1
output.imbue( loc );
output << '\t' << test_bool << '\n';
BOOST_CHECK( &err == output.pword(my_index) );
BOOST_CHECK( 69L == output.iword(my_index) );
BOOST_TEST( &err == output.pword(my_index) );
BOOST_TEST( 69L == output.iword(my_index) );
try
{
@ -195,7 +192,7 @@ saver_tests_1
#endif
{
err << "Got the expected I/O failure: \"" << f.what() << "\".\n";
BOOST_CHECK( output.exceptions() == ios_base::goodbit );
BOOST_TEST( output.exceptions() == ios_base::goodbit );
}
catch ( ... )
{
@ -239,8 +236,8 @@ saver_tests_2
boost::io::ios_locale_saver const ils( output, loc );
output << '\t' << test_bool << '\n';
BOOST_CHECK( &err == output.pword(my_index) );
BOOST_CHECK( 69L == output.iword(my_index) );
BOOST_TEST( &err == output.pword(my_index) );
BOOST_TEST( 69L == output.iword(my_index) );
try
{
@ -257,7 +254,7 @@ saver_tests_2
#endif
{
err << "Got the expected I/O failure: \"" << f.what() << "\".\n";
BOOST_CHECK( output.exceptions() == ios_base::goodbit );
BOOST_TEST( output.exceptions() == ios_base::goodbit );
}
catch ( ... )
{

369
test/ios_state_unit_test.cpp
View File

@ -4,6 +4,9 @@
// subject to the Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
// Copyright 2019 Glen Joseph Fernandes
// (glenjofe@gmail.com)
// See <http://www.boost.org/libs/io/> for the library's home page.
// Revision History
@ -11,7 +14,7 @@
#include <boost/config.hpp>
#include <boost/io/ios_state.hpp> // for boost::io::ios_flags_saver, etc.
#include <boost/test/unit_test.hpp> // for main, BOOST_CHECK, etc.
#include <boost/core/lightweight_test.hpp>
#include <cstddef> // for NULL
#include <iomanip> // for std::setiosflags, etc.
@ -60,33 +63,33 @@ ios_flags_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() );
{
boost::io::ios_flags_saver ifs( ss );
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() );
ss << noskipws << fixed << boolalpha;
BOOST_CHECK_EQUAL( (ios_base::boolalpha | ios_base::dec
BOOST_TEST_EQ( (ios_base::boolalpha | ios_base::dec
| ios_base::fixed), ss.flags() );
}
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() );
{
boost::io::ios_flags_saver ifs( ss, (ios_base::showbase
| ios_base::internal) );
BOOST_CHECK_EQUAL( (ios_base::showbase | ios_base::internal),
BOOST_TEST_EQ( (ios_base::showbase | ios_base::internal),
ss.flags() );
ss << setiosflags( ios_base::unitbuf );
BOOST_CHECK_EQUAL( (ios_base::showbase | ios_base::internal
BOOST_TEST_EQ( (ios_base::showbase | ios_base::internal
| ios_base::unitbuf), ss.flags() );
}
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_TEST_EQ( (ios_base::skipws | ios_base::dec), ss.flags() );
}
// Unit test for precision saving
@ -99,29 +102,29 @@ ios_precision_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_TEST_EQ( 6, ss.precision() );
{
boost::io::ios_precision_saver ips( ss );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_TEST_EQ( 6, ss.precision() );
ss << setprecision( 4 );
BOOST_CHECK_EQUAL( 4, ss.precision() );
BOOST_TEST_EQ( 4, ss.precision() );
}
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_TEST_EQ( 6, ss.precision() );
{
boost::io::ios_precision_saver ips( ss, 8 );
BOOST_CHECK_EQUAL( 8, ss.precision() );
BOOST_TEST_EQ( 8, ss.precision() );
ss << setprecision( 10 );
BOOST_CHECK_EQUAL( 10, ss.precision() );
BOOST_TEST_EQ( 10, ss.precision() );
}
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_TEST_EQ( 6, ss.precision() );
}
// Unit test for width saving
@ -134,29 +137,29 @@ ios_width_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_TEST_EQ( 0, ss.width() );
{
boost::io::ios_width_saver iws( ss );
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_TEST_EQ( 0, ss.width() );
ss << setw( 4 );
BOOST_CHECK_EQUAL( 4, ss.width() );
BOOST_TEST_EQ( 4, ss.width() );
}
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_TEST_EQ( 0, ss.width() );
{
boost::io::ios_width_saver iws( ss, 8 );
BOOST_CHECK_EQUAL( 8, ss.width() );
BOOST_TEST_EQ( 8, ss.width() );
ss << setw( 10 );
BOOST_CHECK_EQUAL( 10, ss.width() );
BOOST_TEST_EQ( 10, ss.width() );
}
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_TEST_EQ( 0, ss.width() );
}
// Unit test for I/O-state saving
@ -169,43 +172,43 @@ ios_iostate_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() );
BOOST_TEST( ss.good() );
{
boost::io::ios_iostate_saver iis( ss );
char c;
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() );
BOOST_TEST( ss.good() );
ss >> c;
BOOST_CHECK_EQUAL( (ios_base::eofbit | ios_base::failbit),
BOOST_TEST_EQ( (ios_base::eofbit | ios_base::failbit),
ss.rdstate() );
BOOST_CHECK( ss.eof() );
BOOST_CHECK( ss.fail() );
BOOST_CHECK( !ss.bad() );
BOOST_TEST( ss.eof() );
BOOST_TEST( ss.fail() );
BOOST_TEST( !ss.bad() );
}
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() );
BOOST_TEST( ss.good() );
{
boost::io::ios_iostate_saver iis( ss, ios_base::eofbit );
BOOST_CHECK_EQUAL( ios_base::eofbit, ss.rdstate() );
BOOST_CHECK( ss.eof() );
BOOST_TEST_EQ( ios_base::eofbit, ss.rdstate() );
BOOST_TEST( ss.eof() );
ss.setstate( ios_base::badbit );
BOOST_CHECK_EQUAL( (ios_base::eofbit | ios_base::badbit),
BOOST_TEST_EQ( (ios_base::eofbit | ios_base::badbit),
ss.rdstate() );
BOOST_CHECK( ss.eof() );
BOOST_CHECK( ss.fail() );
BOOST_CHECK( ss.bad() );
BOOST_TEST( ss.eof() );
BOOST_TEST( ss.fail() );
BOOST_TEST( ss.bad() );
}
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_TEST_EQ( ios_base::goodbit, ss.rdstate() );
BOOST_TEST( ss.good() );
}
// Unit test for exception-flag saving
@ -218,15 +221,15 @@ ios_exception_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() );
{
boost::io::ios_exception_saver ies( ss );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() );
ss.exceptions( ios_base::failbit );
BOOST_CHECK_EQUAL( ios_base::failbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::failbit, ss.exceptions() );
{
boost::io::ios_iostate_saver iis( ss );
@ -234,32 +237,32 @@ ios_exception_saver_unit_test
char c;
#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
BOOST_CHECK_THROW( ss >> c, std::exception );
BOOST_TEST_THROWS( ss >> c, std::exception );
#else
BOOST_CHECK_THROW( ss >> c, std::ios_base::failure );
BOOST_TEST_THROWS( ss >> c, std::ios_base::failure );
#endif
}
}
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() );
{
boost::io::ios_exception_saver ies( ss, ios_base::eofbit );
BOOST_CHECK_EQUAL( ios_base::eofbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::eofbit, ss.exceptions() );
ss.exceptions( ios_base::badbit );
BOOST_CHECK_EQUAL( ios_base::badbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::badbit, ss.exceptions() );
{
boost::io::ios_iostate_saver iis( ss );
char c;
BOOST_CHECK_NO_THROW( ss >> c );
BOOST_TEST_NOT( ss >> c );
}
}
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::goodbit, ss.exceptions() );
}
// Unit test for tied-stream saving
@ -270,29 +273,29 @@ ios_tie_saver_unit_test
{
using namespace std;
BOOST_CHECK( NULL == cout.tie() );
BOOST_TEST( NULL == cout.tie() );
{
boost::io::ios_tie_saver its( cout );
BOOST_CHECK( NULL == cout.tie() );
BOOST_TEST( NULL == cout.tie() );
cout.tie( &clog );
BOOST_CHECK_EQUAL( &clog, cout.tie() );
BOOST_TEST_EQ( &clog, cout.tie() );
}
BOOST_CHECK( NULL == cout.tie() );
BOOST_TEST( NULL == cout.tie() );
{
boost::io::ios_tie_saver its( cout, &clog );
BOOST_CHECK_EQUAL( &clog, cout.tie() );
BOOST_TEST_EQ( &clog, cout.tie() );
cout.tie( &cerr );
BOOST_CHECK_EQUAL( &cerr, cout.tie() );
BOOST_TEST_EQ( &cerr, cout.tie() );
}
BOOST_CHECK( NULL == cout.tie() );
BOOST_TEST( NULL == cout.tie() );
}
// Unit test for connected-streambuf saving
@ -305,31 +308,31 @@ ios_rdbuf_saver_unit_test
iostream s( NULL );
BOOST_CHECK( NULL == s.rdbuf() );
BOOST_TEST( NULL == s.rdbuf() );
{
stringbuf sb;
boost::io::ios_rdbuf_saver irs( s );
BOOST_CHECK( NULL == s.rdbuf() );
BOOST_TEST( NULL == s.rdbuf() );
s.rdbuf( &sb );
BOOST_CHECK_EQUAL( &sb, s.rdbuf() );
BOOST_TEST_EQ( &sb, s.rdbuf() );
}
BOOST_CHECK( NULL == s.rdbuf() );
BOOST_TEST( NULL == s.rdbuf() );
{
stringbuf sb1, sb2( "Hi there" );
boost::io::ios_rdbuf_saver irs( s, &sb1 );
BOOST_CHECK_EQUAL( &sb1, s.rdbuf() );
BOOST_TEST_EQ( &sb1, s.rdbuf() );
s.rdbuf( &sb2 );
BOOST_CHECK_EQUAL( &sb2, s.rdbuf() );
BOOST_TEST_EQ( &sb2, s.rdbuf() );
}
BOOST_CHECK( NULL == s.rdbuf() );
BOOST_TEST( NULL == s.rdbuf() );
}
// Unit test for fill-character saving
@ -342,29 +345,29 @@ ios_fill_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_TEST_EQ( ' ', ss.fill() );
{
boost::io::ios_fill_saver ifs( ss );
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_TEST_EQ( ' ', ss.fill() );
ss.fill( 'x' );
BOOST_CHECK_EQUAL( 'x', ss.fill() );
BOOST_TEST_EQ( 'x', ss.fill() );
}
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_TEST_EQ( ' ', ss.fill() );
{
boost::io::ios_fill_saver ifs( ss, '3' );
BOOST_CHECK_EQUAL( '3', ss.fill() );
BOOST_TEST_EQ( '3', ss.fill() );
ss.fill( '+' );
BOOST_CHECK_EQUAL( '+', ss.fill() );
BOOST_TEST_EQ( '+', ss.fill() );
}
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_TEST_EQ( ' ', ss.fill() );
}
// Unit test for locale saving
@ -379,48 +382,48 @@ ios_locale_saver_unit_test
stringstream ss;
BOOST_CHECK( locale() == ss.getloc() );
// locales are unprintable, so no BOOST_CHECK_EQUAL
BOOST_CHECK( !has_facet<npc_type>(ss.getloc()) || (NULL
BOOST_TEST( locale() == ss.getloc() );
// locales are unprintable, so no BOOST_TEST_EQ
BOOST_TEST( !has_facet<npc_type>(ss.getloc()) || (NULL
== dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(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_CHECK( ! has_facet< backward_bool_names >(
// here. I wanted: "BOOST_TEST( ! has_facet< backward_bool_names >(
// ss.getloc() ) )"
{
boost::io::ios_locale_saver ils( ss );
BOOST_CHECK( locale() == ss.getloc() );
BOOST_TEST( locale() == ss.getloc() );
ss.imbue( locale::classic() );
BOOST_CHECK( locale::classic() == ss.getloc() );
BOOST_TEST( locale::classic() == ss.getloc() );
}
BOOST_CHECK( locale() == ss.getloc() );
BOOST_CHECK( !has_facet<npc_type>(ss.getloc()) || (NULL
BOOST_TEST( locale() == ss.getloc() );
BOOST_TEST( !has_facet<npc_type>(ss.getloc()) || (NULL
== dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(ss.getloc()) )) );
{
boost::io::ios_locale_saver ils( ss, locale::classic() );
BOOST_CHECK( locale::classic() == ss.getloc() );
BOOST_CHECK( !has_facet<npc_type>(ss.getloc()) || (NULL
BOOST_TEST( locale::classic() == ss.getloc() );
BOOST_TEST( !has_facet<npc_type>(ss.getloc()) || (NULL
== dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(ss.getloc()) )) );
ss.imbue( locale(locale::classic(), new backward_bool_names) );
BOOST_CHECK( locale::classic() != ss.getloc() );
BOOST_CHECK( has_facet<npc_type>(ss.getloc()) && (NULL
BOOST_TEST( locale::classic() != ss.getloc() );
BOOST_TEST( has_facet<npc_type>(ss.getloc()) && (NULL
!= dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(ss.getloc()) )) );
//BOOST_CHECK( has_facet<backward_bool_names>(ss.getloc()) );
//BOOST_TEST( has_facet<backward_bool_names>(ss.getloc()) );
}
BOOST_CHECK( locale() == ss.getloc() );
BOOST_CHECK( !has_facet<npc_type>(ss.getloc()) || (NULL
BOOST_TEST( locale() == ss.getloc() );
BOOST_TEST( !has_facet<npc_type>(ss.getloc()) || (NULL
== dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(ss.getloc()) )) );
}
@ -435,29 +438,29 @@ ios_iword_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
{
boost::io::ios_iword_saver iis( ss, word_index );
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
ss.iword( word_index ) = 6;
BOOST_CHECK_EQUAL( 6, ss.iword(word_index) );
BOOST_TEST_EQ( 6, ss.iword(word_index) );
}
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
{
boost::io::ios_iword_saver iis( ss, word_index, 100 );
BOOST_CHECK_EQUAL( 100, ss.iword(word_index) );
BOOST_TEST_EQ( 100, ss.iword(word_index) );
ss.iword( word_index ) = -2000;
BOOST_CHECK_EQUAL( -2000, ss.iword(word_index) );
BOOST_TEST_EQ( -2000, ss.iword(word_index) );
}
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
}
// Unit test for user-defined pointer data saving
@ -470,29 +473,29 @@ ios_pword_saver_unit_test
stringstream ss;
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
{
boost::io::ios_pword_saver ips( ss, word_index );
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
ss.pword( word_index ) = &ss;
BOOST_CHECK_EQUAL( &ss, ss.pword(word_index) );
BOOST_TEST_EQ( &ss, ss.pword(word_index) );
}
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
{
boost::io::ios_pword_saver ips( ss, word_index, ss.rdbuf() );
BOOST_CHECK_EQUAL( ss.rdbuf(), ss.pword(word_index) );
BOOST_TEST_EQ( ss.rdbuf(), ss.pword(word_index) );
ss.pword( word_index ) = &ss;
BOOST_CHECK_EQUAL( &ss, ss.pword(word_index) );
BOOST_TEST_EQ( &ss, ss.pword(word_index) );
}
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
}
// Unit test for all ios_base data saving
@ -505,27 +508,27 @@ ios_base_all_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, 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::io::ios_base_all_saver ibas( ss );
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, 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() );
ss << hex << unitbuf << setprecision( 5 ) << setw( 7 );
BOOST_CHECK_EQUAL( (ios_base::unitbuf | ios_base::hex
BOOST_TEST_EQ( (ios_base::unitbuf | ios_base::hex
| ios_base::skipws), ss.flags() );
BOOST_CHECK_EQUAL( 5, ss.precision() );
BOOST_CHECK_EQUAL( 7, ss.width() );
BOOST_TEST_EQ( 5, ss.precision() );
BOOST_TEST_EQ( 7, ss.width() );
}
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, 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() );
}
// Unit test for all basic_ios data saving
@ -541,46 +544,46 @@ ios_all_saver_unit_test
stringbuf sb;
iostream ss( &sb );
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_CHECK( NULL == ss.tie() );
BOOST_CHECK( &sb == ss.rdbuf() );
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_CHECK( locale() == 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::io::ios_all_saver ias( ss );
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_CHECK( NULL == ss.tie() );
BOOST_CHECK( &sb == ss.rdbuf() );
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_CHECK( locale() == 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() );
ss << oct << showpos << noskipws;
BOOST_CHECK_EQUAL( (ios_base::showpos | ios_base::oct), ss.flags() );
BOOST_TEST_EQ( (ios_base::showpos | ios_base::oct), ss.flags() );
ss << setprecision( 3 );
BOOST_CHECK_EQUAL( 3, ss.precision() );
BOOST_TEST_EQ( 3, ss.precision() );
ss << setw( 9 );
BOOST_CHECK_EQUAL( 9, ss.width() );
BOOST_TEST_EQ( 9, ss.width() );
ss.setstate( ios_base::eofbit );
BOOST_CHECK_EQUAL( ios_base::eofbit, ss.rdstate() );
BOOST_CHECK( ss.eof() );
BOOST_TEST_EQ( ios_base::eofbit, ss.rdstate() );
BOOST_TEST( ss.eof() );
ss.exceptions( ios_base::failbit );
BOOST_CHECK_EQUAL( ios_base::failbit, ss.exceptions() );
BOOST_TEST_EQ( ios_base::failbit, ss.exceptions() );
{
boost::io::ios_iostate_saver iis( ss );
@ -588,38 +591,38 @@ ios_all_saver_unit_test
char c;
#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
BOOST_CHECK_THROW( ss >> c, std::exception );
BOOST_TEST_THROWS( ss >> c, std::exception );
#else
BOOST_CHECK_THROW( ss >> c, std::ios_base::failure );
BOOST_TEST_THROWS( ss >> c, std::ios_base::failure );
#endif
}
ss.tie( &clog );
BOOST_CHECK_EQUAL( &clog, ss.tie() );
BOOST_TEST_EQ( &clog, ss.tie() );
ss.rdbuf( cerr.rdbuf() );
BOOST_CHECK_EQUAL( cerr.rdbuf(), ss.rdbuf() );
BOOST_TEST_EQ( cerr.rdbuf(), ss.rdbuf() );
ss << setfill( 'x' );
BOOST_CHECK_EQUAL( 'x', ss.fill() );
BOOST_TEST_EQ( 'x', ss.fill() );
ss.imbue( locale(locale::classic(), new backward_bool_names) );
BOOST_CHECK( locale() != ss.getloc() );
BOOST_CHECK( has_facet<npc_type>(ss.getloc()) && (NULL
BOOST_TEST( locale() != ss.getloc() );
BOOST_TEST( has_facet<npc_type>(ss.getloc()) && (NULL
!= dynamic_cast<backward_bool_names const *>(
&use_facet<npc_type>(ss.getloc()) )) );
}
BOOST_CHECK_EQUAL( (ios_base::skipws | ios_base::dec), ss.flags() );
BOOST_CHECK_EQUAL( 6, ss.precision() );
BOOST_CHECK_EQUAL( 0, ss.width() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.rdstate() );
BOOST_CHECK( ss.good() );
BOOST_CHECK_EQUAL( ios_base::goodbit, ss.exceptions() );
BOOST_CHECK( NULL == ss.tie() );
BOOST_CHECK( &sb == ss.rdbuf() );
BOOST_CHECK_EQUAL( ' ', ss.fill() );
BOOST_CHECK( locale() == 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() );
}
// Unit test for user-defined data saving
@ -632,54 +635,46 @@ ios_word_saver_unit_test
stringstream ss;
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
{
boost::io::ios_all_word_saver iaws( ss, word_index );
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_CHECK( NULL == ss.pword(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_CHECK_EQUAL( -11, ss.iword(word_index) );
BOOST_CHECK_EQUAL( ss.rdbuf(), ss.pword(word_index) );
BOOST_TEST_EQ( -11, ss.iword(word_index) );
BOOST_TEST_EQ( ss.rdbuf(), ss.pword(word_index) );
}
BOOST_CHECK_EQUAL( 0, ss.iword(word_index) );
BOOST_CHECK( NULL == ss.pword(word_index) );
BOOST_TEST_EQ( 0, ss.iword(word_index) );
BOOST_TEST( NULL == ss.pword(word_index) );
}
// Unit test program
boost::unit_test::test_suite *
init_unit_test_suite
(
int , // "argc" is unused
char * [] // "argv" is unused
)
int main()
{
boost::unit_test::test_suite * test
= BOOST_TEST_SUITE( "I/O state saver test" );
ios_flags_saver_unit_test();
ios_precision_saver_unit_test();
ios_width_saver_unit_test();
test->add( BOOST_TEST_CASE(ios_flags_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_precision_saver_unit_test) );
test->add( BOOST_TEST_CASE(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();
test->add( BOOST_TEST_CASE(ios_iostate_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_exception_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_tie_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_rdbuf_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_fill_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_locale_saver_unit_test) );
ios_iword_saver_unit_test();
ios_pword_saver_unit_test();
test->add( BOOST_TEST_CASE(ios_iword_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_pword_saver_unit_test) );
ios_base_all_saver_unit_test();
ios_all_saver_unit_test();
ios_word_saver_unit_test();
test->add( BOOST_TEST_CASE(ios_base_all_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_all_saver_unit_test) );
test->add( BOOST_TEST_CASE(ios_word_saver_unit_test) );
return test;
return boost::report_errors();
}

2
test/quoted_manip_test.cpp
View File

@ -10,7 +10,7 @@
// ---------------------------------------------------------------------------------- //
#include <boost/io/detail/quoted_manip.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/core/lightweight_test.hpp>
#include <iostream>
#include <sstream>