int read_test2(TEST_DATA *data, IO_BUFFER *iobuf) { IO_ITEM_HEADER item_header; int i; item_header.type = 99; /* test data */ if ( get_item_begin(iobuf,&item_header) < 0 ) { Warning("Missing or invalid test data block."); return -4; } get_vector_of_long(data->lvar,2,iobuf); data->ilvar[0] = get_long(iobuf); data->ilvar[1] = get_long(iobuf); get_vector_of_int(data->isvar,2,iobuf); get_vector_of_short(data->svar,3,iobuf); get_vector_of_real(data->fvar,2,iobuf); get_vector_of_double(data->dvar,2,iobuf); data->hvar[0] = get_sfloat(iobuf); data->hvar[1] = get_sfloat(iobuf); get_vector_of_byte((uint8_t *)data->i8var,2,iobuf); get_vector_of_byte(data->u8var,2,iobuf); get_vector_of_short(data->i16var,2,iobuf); get_vector_of_short((int16_t *)data->u16var,2,iobuf); get_vector_of_int32(data->i32var,2,iobuf); get_vector_of_uint32(data->u32var,2,iobuf); #ifdef HAVE_64BIT_INT get_vector_of_int64(data->i64var,2,iobuf); get_vector_of_uint64(data->u64var,2,iobuf); #endif data->nbvar = get_count(iobuf); get_vector_of_byte(data->bvar,2,iobuf); for (i=0; i<4; i++) data->cnt16var[i] = get_count(iobuf); for (i=0; i<6; i++) data->cnt32var[i] = get_count(iobuf); for (i=0; i<6; i++) data->cntzvar[i] = get_count(iobuf); for (i=0; i<8; i++) data->cntvar[i] = get_count(iobuf); for (i=0; i<10; i++) data->scnt16var[i] = get_scount16(iobuf); for (i=0; i<12; i++) data->scnt32var[i] = get_scount32(iobuf); for (i=0; i<12; i++) data->scntzvar[i] = get_scount(iobuf); for (i=0; i<14; i++) data->scntvar[i] = get_scount(iobuf); get_string(data->str16var,sizeof(data->str16var),iobuf); get_long_string(data->str32var,sizeof(data->str32var),iobuf); get_var_string(data->strvvar,sizeof(data->strvvar),iobuf); return(get_item_end(iobuf,&item_header)); }
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) { // a bunch of typedefs which will be handy later on typedef boost::dynamic_bitset<Block> bitset_type; typedef bitset_test<bitset_type> Tests; // typedef typename bitset_type::size_type size_type; // unusable with Borland 5.5.1 std::string long_string = get_long_string(); std::size_t ul_width = std::numeric_limits<unsigned long>::digits; //===================================================================== // Test b.empty() { bitset_type b; Tests::empty(b); } { bitset_type b(1, 1ul); Tests::empty(b); } { bitset_type b(bitset_type::bits_per_block + bitset_type::bits_per_block/2, 15ul); Tests::empty(b); } //===================================================================== // Test b.to_long() { boost::dynamic_bitset<Block> b; Tests::to_ulong(b); } { boost::dynamic_bitset<Block> b(std::string("1")); Tests::to_ulong(b); } { boost::dynamic_bitset<Block> b(bitset_type::bits_per_block, static_cast<unsigned long>(-1)); Tests::to_ulong(b); } { std::string str(ul_width - 1, '1'); boost::dynamic_bitset<Block> b(str); Tests::to_ulong(b); } { std::string ul_str(ul_width, '1'); boost::dynamic_bitset<Block> b(ul_str); Tests::to_ulong(b); } { // case overflow boost::dynamic_bitset<Block> b(long_string); Tests::to_ulong(b); } //===================================================================== // Test to_string(b, str) { boost::dynamic_bitset<Block> b; Tests::to_string(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::to_string(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::to_string(b); } //===================================================================== // Test b.count() { boost::dynamic_bitset<Block> b; Tests::count(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::count(b); } { boost::dynamic_bitset<Block> b(std::string("1")); Tests::count(b); } { boost::dynamic_bitset<Block> b(8, 255ul); Tests::count(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::count(b); } //===================================================================== // Test b.size() { boost::dynamic_bitset<Block> b; Tests::size(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::size(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::size(b); } //===================================================================== // Test b.any() { boost::dynamic_bitset<Block> b; Tests::any(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::any(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::any(b); } //===================================================================== // Test b.none() { boost::dynamic_bitset<Block> b; Tests::none(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::none(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::none(b); } //===================================================================== // Test a.is_subset_of(b) { boost::dynamic_bitset<Block> a, b; Tests::subset(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::subset(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::subset(a, b); } //===================================================================== // Test a.is_proper_subset_of(b) { boost::dynamic_bitset<Block> a, b; Tests::proper_subset(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::proper_subset(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::proper_subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::proper_subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::proper_subset(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::proper_subset(a, b); } //===================================================================== // Test intersects { bitset_type a; // empty bitset_type b; Tests::intersects(a, b); } { bitset_type a; bitset_type b(5, 8ul); Tests::intersects(a, b); } { bitset_type a(8, 0ul); bitset_type b(15, 0ul); b[9] = 1; Tests::intersects(a, b); } { bitset_type a(15, 0ul); bitset_type b(22, 0ul); a[14] = b[14] = 1; Tests::intersects(a, b); } //===================================================================== // Test find_first { // empty bitset bitset_type b; Tests::find_first(b); } { // bitset of size 1 bitset_type b(1, 1ul); Tests::find_first(b); } { // all-0s bitset bitset_type b(4 * bitset_type::bits_per_block, 0ul); Tests::find_first(b); } { // first bit on bitset_type b(1, 1ul); Tests::find_first(b); } { // last bit on bitset_type b(4 * bitset_type::bits_per_block - 1, 0ul); b.set(b.size() - 1); Tests::find_first(b); } //===================================================================== // Test find_next { // empty bitset bitset_type b; // check Tests::find_next(b, 0); Tests::find_next(b, 1); Tests::find_next(b, 200); Tests::find_next(b, b.npos); } { // bitset of size 1 (find_next can never find) bitset_type b(1, 1ul); // check Tests::find_next(b, 0); Tests::find_next(b, 1); Tests::find_next(b, 200); Tests::find_next(b, b.npos); } { // all-1s bitset bitset_type b(16 * bitset_type::bits_per_block); b.set(); // check const typename bitset_type::size_type larger_than_size = 5 + b.size(); for(typename bitset_type::size_type i = 0; i <= larger_than_size; ++i) { Tests::find_next(b, i); } Tests::find_next(b, b.npos); } { // a bitset with 1s at block boundary only const int num_blocks = 32; const int block_width = bitset_type::bits_per_block; bitset_type b(num_blocks * block_width); typename bitset_type::size_type i = block_width - 1; for ( ; i < b.size(); i += block_width) { b.set(i); typename bitset_type::size_type first_in_block = i - (block_width - 1); b.set(first_in_block); } // check const typename bitset_type::size_type larger_than_size = 5 + b.size(); for (i = 0; i <= larger_than_size; ++i) { Tests::find_next(b, i); } Tests::find_next(b, b.npos); } { // bitset with alternate 1s and 0s const typename bitset_type::size_type sz = 1000; bitset_type b(sz); typename bitset_type::size_type i = 0; for ( ; i < sz; ++i) { b[i] = (i%2 == 0); } // check const typename bitset_type::size_type larger_than_size = 5 + b.size(); for (i = 0; i <= larger_than_size; ++i) { Tests::find_next(b, i); } Tests::find_next(b, b.npos); } //===================================================================== // Test operator== { boost::dynamic_bitset<Block> a, b; Tests::operator_equal(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_equal(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_equal(a, b); } //===================================================================== // Test operator!= { boost::dynamic_bitset<Block> a, b; Tests::operator_not_equal(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_not_equal(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_not_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_not_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_not_equal(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_not_equal(a, b); } //===================================================================== // Test operator< { boost::dynamic_bitset<Block> a, b; Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("11")); Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_less_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_less_than(a, b); } // check for consistency with ulong behaviour { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul); assert(a < b); } { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul); assert(!(a < b)); } { boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul); assert(!(a < b)); } //===================================================================== // Test operator<= { boost::dynamic_bitset<Block> a, b; Tests::operator_less_than_eq(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_less_than_eq(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_less_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_less_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_less_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_less_than_eq(a, b); } // check for consistency with ulong behaviour { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul); assert(a <= b); } { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul); assert(a <= b); } { boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul); assert(!(a <= b)); } //===================================================================== // Test operator> { boost::dynamic_bitset<Block> a, b; Tests::operator_greater_than(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_greater_than(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_greater_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_greater_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_greater_than(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_greater_than(a, b); } // check for consistency with ulong behaviour { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul); assert(!(a > b)); } { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul); assert(!(a > b)); } { boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul); assert(a > b); } //===================================================================== // Test operator<= { boost::dynamic_bitset<Block> a, b; Tests::operator_greater_than_eq(a, b); } { boost::dynamic_bitset<Block> a(std::string("0")), b(std::string("0")); Tests::operator_greater_than_eq(a, b); } { boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1")); Tests::operator_greater_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); Tests::operator_greater_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); a[long_string.size()/2].flip(); Tests::operator_greater_than_eq(a, b); } { boost::dynamic_bitset<Block> a(long_string), b(long_string); b[long_string.size()/2].flip(); Tests::operator_greater_than_eq(a, b); } // check for consistency with ulong behaviour { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul); assert(!(a >= b)); } { boost::dynamic_bitset<Block> a(3, 4ul), b(3, 4ul); assert(a >= b); } { boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul); assert(a >= b); } //===================================================================== // Test b.test(pos) { // case pos >= b.size() boost::dynamic_bitset<Block> b; Tests::test_bit(b, 0); } { // case pos < b.size() boost::dynamic_bitset<Block> b(std::string("0")); Tests::test_bit(b, 0); } { // case pos == b.size() / 2 boost::dynamic_bitset<Block> b(long_string); Tests::test_bit(b, long_string.size()/2); } //===================================================================== // Test b << pos { // case pos == 0 std::size_t pos = 0; boost::dynamic_bitset<Block> b(std::string("1010")); Tests::operator_shift_left(b, pos); } { // case pos == size()/2 std::size_t pos = long_string.size() / 2; boost::dynamic_bitset<Block> b(long_string); Tests::operator_shift_left(b, pos); } { // case pos >= n std::size_t pos = long_string.size(); boost::dynamic_bitset<Block> b(long_string); Tests::operator_shift_left(b, pos); } //===================================================================== // Test b >> pos { // case pos == 0 std::size_t pos = 0; boost::dynamic_bitset<Block> b(std::string("1010")); Tests::operator_shift_right(b, pos); } { // case pos == size()/2 std::size_t pos = long_string.size() / 2; boost::dynamic_bitset<Block> b(long_string); Tests::operator_shift_right(b, pos); } { // case pos >= n std::size_t pos = long_string.size(); boost::dynamic_bitset<Block> b(long_string); Tests::operator_shift_right(b, pos); } //===================================================================== // Test a & b { boost::dynamic_bitset<Block> lhs, rhs; Tests::operator_and(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::operator_and(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::operator_and(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::operator_and(lhs, rhs); } //===================================================================== // Test a | b { boost::dynamic_bitset<Block> lhs, rhs; Tests::operator_or(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::operator_or(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::operator_or(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::operator_or(lhs, rhs); } //===================================================================== // Test a^b { boost::dynamic_bitset<Block> lhs, rhs; Tests::operator_xor(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::operator_xor(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::operator_xor(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::operator_xor(lhs, rhs); } //===================================================================== // Test a-b { boost::dynamic_bitset<Block> lhs, rhs; Tests::operator_sub(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::operator_sub(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::operator_sub(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::operator_sub(lhs, rhs); } }
int read_test3(TEST_DATA *data, IO_BUFFER *iobuf) { IO_ITEM_HEADER item_header1, item_header2; int i; item_header1.type = 990; /* test data */ if ( get_item_begin(iobuf,&item_header1) < 0 ) { Warning("Missing or invalid test data block."); return -4; } item_header2.type = 991; /* test data */ if ( get_item_begin(iobuf,&item_header2) < 0 ) { Warning("Missing or invalid test data sub-block 1."); return -4; } get_vector_of_long(data->lvar,2,iobuf); data->ilvar[0] = get_long(iobuf); data->ilvar[1] = get_long(iobuf); get_vector_of_int(data->isvar,2,iobuf); get_vector_of_short(data->svar,3,iobuf); get_item_end(iobuf,&item_header2); if ( next_subitem_type(iobuf) != 992 ) { Warning("Failed to look ahead for next sub-item type."); return -4; } item_header2.type = 992; /* test data */ if ( get_item_begin(iobuf,&item_header2) < 0 ) { Warning("Missing or invalid test data sub-block 2."); return -4; } get_vector_of_real(data->fvar,2,iobuf); get_vector_of_double(data->dvar,2,iobuf); data->hvar[0] = get_sfloat(iobuf); data->hvar[1] = get_sfloat(iobuf); get_vector_of_byte((uint8_t *)data->i8var,2,iobuf); get_vector_of_byte(data->u8var,2,iobuf); get_vector_of_short(data->i16var,2,iobuf); get_vector_of_short((int16_t *)data->u16var,2,iobuf); get_vector_of_int32(data->i32var,2,iobuf); get_vector_of_uint32(data->u32var,2,iobuf); #ifdef HAVE_64BIT_INT get_vector_of_int64(data->i64var,2,iobuf); get_vector_of_uint64(data->u64var,2,iobuf); #endif get_item_end(iobuf,&item_header2); /* Check that non-sequential access to sub-items also works */ rewind_item(iobuf,&item_header1); item_header2.type = 994; /* test data */ if ( search_sub_item(iobuf,&item_header1,&item_header2) < 0 ) { Warning("Cannot find test data sub-block 4."); return -4; } if ( get_item_begin(iobuf,&item_header2) < 0 ) { Warning("Missing or invalid test data sub-block 4."); return -4; } get_string(data->str16var,sizeof(data->str16var),iobuf); get_long_string(data->str32var,sizeof(data->str32var),iobuf); get_var_string(data->strvvar,sizeof(data->strvvar),iobuf); get_item_end(iobuf,&item_header2); rewind_item(iobuf,&item_header1); item_header2.type = 993; /* test data */ if ( search_sub_item(iobuf,&item_header1,&item_header2) < 0 ) { Warning("Cannot find test data sub-block 3."); return -4; } if ( get_item_begin(iobuf,&item_header2) < 0 ) { Warning("Missing or invalid test data sub-block 3."); return -4; } data->nbvar = get_count(iobuf); get_vector_of_byte(data->bvar,2,iobuf); for (i=0; i<4; i++) data->cnt16var[i] = get_count(iobuf); for (i=0; i<6; i++) data->cnt32var[i] = get_count(iobuf); for (i=0; i<6; i++) data->cntzvar[i] = get_count(iobuf); for (i=0; i<8; i++) data->cntvar[i] = get_count(iobuf); for (i=0; i<10; i++) data->scnt16var[i] = get_scount16(iobuf); for (i=0; i<12; i++) data->scnt32var[i] = get_scount32(iobuf); for (i=0; i<12; i++) data->scntzvar[i] = get_scount(iobuf); for (i=0; i<14; i++) data->scntvar[i] = get_scount(iobuf); get_item_end(iobuf,&item_header2); return(get_item_end(iobuf,&item_header1)); }
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) { typedef boost::dynamic_bitset<Block> bitset_type; typedef bitset_test<bitset_type> Tests; //===================================================================== // Test stream operator<< { // The test "variables" are: the stream type and its state, the // exception mask, the width, the fill char and the padding side (left/right) std::ios::iostate masks[] = { std::ios::goodbit, std::ios::eofbit, std::ios::failbit, std::ios::eofbit | std::ios::failbit }; static std::string strings[] = { std::string(""), std::string("0"), std::string("1"), std::string("11100"), get_long_string() }; char fill_chars[] = { '*', 'x', ' ' }; std::size_t num_masks = sizeof(masks) / sizeof(masks[0]); std::size_t num_strings = sizeof(strings) / sizeof(strings[0]); std::size_t num_chars = sizeof(fill_chars) / sizeof(fill_chars[0]); std::fstream not_good_stream("dynamic_bitset_tests - this file shouldn't exist", std::ios::in); for (std::size_t mi = 0; mi < num_masks; ++mi) { for (std::size_t si = 0; si < num_strings; ++si) { std::streamsize slen = (std::streamsize)(strings[si].length()); assert( (std::numeric_limits<std::streamsize>::max)() >=(std::streamsize)(1+slen*2) ); for (std::size_t ci = 0; ci < num_chars; ++ci) { // note how "negative widths" are tested too const std::streamsize widths[] = { -1 - slen/2, 0, slen/2, 1 + slen*2 }; std::size_t num_widths = sizeof(widths) / sizeof(widths[0]); for (std::size_t wi = 0; wi < num_widths; ++wi) { std::streamsize w = widths[wi]; { // test 0 - stream !good() if(not_good_stream.good()) throw std::logic_error("Error in operator << tests" " - please, double check"); bitset_type b(strings[si]); not_good_stream.width(w); not_good_stream.fill(fill_chars[ci]); try { not_good_stream.exceptions(masks[mi]); } catch(...) {} Tests::stream_inserter(b, not_good_stream, "<unused_string>"); } { // test 1a - file stream bitset_type b(strings[si]); std::ofstream file(test_file_name(), std::ios::trunc); file.width(w); file.fill(fill_chars[ci]); file.exceptions(masks[mi]); Tests::stream_inserter(b, file, test_file_name()); } { //NOTE: there are NO string stream tests - gps } #if !defined (BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS) { // test 1b - wide file stream bitset_type b(strings[si]); std::wofstream file(test_file_name()); file.width(w); file.fill(fill_chars[ci]); file.exceptions(masks[mi]); Tests::stream_inserter(b, file, test_file_name()); } #endif } } } } // for (; mi..) } //===================================================================== // Test stream operator>> { // The test "variables" are: the stream type, the exception mask, // the actual contents (and/or state) of the stream, and width. // // With few exceptions, each test case consists of writing a different // assortment of digits and "whitespaces" to a text stream and then checking // that what was written gets read back unchanged. That's NOT guaranteed by // the standard, unless the assortment always ends with a '\n' and satisfies // other conditions (see C99, 7.19.2/2), however it works in practice and is // a good "real life" test. Some characters, such as '\v' and '\f', are not // used exactly because they are the ones which will most likely give problems // on some systems (for instance '\f' could actually be written as a sequence // of new-lines, and we could never be able to read it back) [gps] // // Note how the bitset object is not initially empty. That helps checking // that it isn't erroneously clear()ed by operator>>. std::ios::iostate masks[] = { std::ios::goodbit, std::ios::eofbit, std::ios::failbit, std::ios::eofbit | std::ios::failbit }; const std::string spaces = "\t\n "; //"\t\n\v\f "; const std::string long_string = get_long_string(); /*const*/ static std::string strings[] = { // NOTE: "const" gives the usual problems with Borland // (in Tests::stream_extractor instantiation) #if !(defined __BORLANDC__ \ && BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))) // Borland 5.5.1 with RW library crashes // empty string std::string(""), // no bitset spaces, #endif // no bitset std::string("x"), std::string("\t xyz"), // bitset of size 1 std::string("0"), std::string("1"), std::string(" 0 "), std::string(" 1 "), spaces + "1", "1" + spaces, spaces + "1" + spaces, std::string(" x1x "), std::string(" 1x "), // long bitset long_string, " " + long_string + " xyz", spaces + long_string, spaces + long_string + spaces }; //----------------------------------------------------- std::stringstream not_good_stream; not_good_stream << "test"; std::string sink; not_good_stream >> sink; // now the stream should be in eof state const std::size_t num_masks = sizeof(masks) / sizeof(masks[0]); const std::size_t num_strings = sizeof(strings) / sizeof(strings[0]); for (std::size_t mi = 0; mi < num_masks; ++mi) { for (std::size_t si = 0; si < num_strings; ++si) { const std::streamsize slen = (std::streamsize)(strings[si].length()); assert((std::numeric_limits<std::streamsize>::max)() >= (std::streamsize)(1+slen*2)); std::streamsize widths[] = { -1, 0, slen/2, slen, 1 + slen*2 }; std::size_t num_widths = sizeof(widths) / sizeof(widths[0]); for(std::size_t wi = 0; wi < num_widths; ++wi) { const std::streamsize w = widths[wi]; // test 0 - !good() stream { if(not_good_stream.good()) throw std::logic_error("Error in operator >> tests" " - please, double check"); bitset_type b(1, 15ul); // note: b is not empty not_good_stream.width(w); try { not_good_stream.exceptions(masks[mi]); } catch(...) {} std::string irrelevant; Tests::stream_extractor(b, not_good_stream, irrelevant); } // test 1a - (narrow) file stream { bitset_type b(1, 255ul); { std::ofstream f(test_file_name()); f << strings[si]; } std::ifstream f(test_file_name()); f.width(w); f.exceptions(masks[mi]); Tests::stream_extractor(b, f, strings[si]); } #if !defined(BOOST_NO_STRINGSTREAM) // test 2a - stringstream { bitset_type b(1, 255ul); std::istringstream stream(strings[si]); stream.width(w); stream.exceptions(masks[mi]); Tests::stream_extractor(b, stream, strings[si]); } #endif #if !defined(BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS) // test 1b - wchar_t file stream { std::wstring wstr = widen_string(strings[si]); bitset_type b(1, 255ul); { std::basic_ofstream<wchar_t> of(test_file_name()); of << wstr; } std::basic_ifstream<wchar_t> f(test_file_name()); f.width(w); f.exceptions(masks[mi]); Tests::stream_extractor(b, f, wstr); } // test 2b - wstringstream { bitset_type b(1, 255ul); std::wstring wstr = widen_string(strings[si]); std::wistringstream wstream(wstr); wstream.width(w); wstream.exceptions(masks[mi]); Tests::stream_extractor(b, wstream, wstr); } #endif // BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS } } } // for ( mi = 0; ...) } //===================================================================== // << Any other tests go here >> // ..... }
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) { typedef boost::dynamic_bitset<Block> bitset_type; typedef bitset_test< bitset_type > Tests; const int bits_per_block = bitset_type::bits_per_block; std::string long_string = get_long_string(); //===================================================================== // Test operator&= { boost::dynamic_bitset<Block> lhs, rhs; Tests::and_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::and_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::and_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::and_assignment(lhs, rhs); } //===================================================================== // Test operator |= { boost::dynamic_bitset<Block> lhs, rhs; Tests::or_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::or_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string); Tests::or_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string); Tests::or_assignment(lhs, rhs); } //===================================================================== // Test operator^= { boost::dynamic_bitset<Block> lhs, rhs; Tests::xor_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::xor_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1")); Tests::xor_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string); Tests::xor_assignment(lhs, rhs); } //===================================================================== // Test operator-= { boost::dynamic_bitset<Block> lhs, rhs; Tests::sub_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0")); Tests::sub_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1")); Tests::sub_assignment(lhs, rhs); } { boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string); Tests::sub_assignment(lhs, rhs); } //===================================================================== // Test operator<<= { // case pos == 0 std::size_t pos = 0; { boost::dynamic_bitset<Block> b; Tests::shift_left_assignment(b, pos); } { boost::dynamic_bitset<Block> b(std::string("1010")); Tests::shift_left_assignment(b, pos); } { boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment(b, pos); } } { // test with both multiple and // non multiple of bits_per_block const int how_many = 10; for (int i = 1; i <= how_many; ++i) { std::size_t multiple = i * bits_per_block; std::size_t non_multiple = multiple - 1; boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment(b, multiple); Tests::shift_left_assignment(b, non_multiple); } } { // case pos == size()/2 std::size_t pos = long_string.size() / 2; boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment(b, pos); } { // case pos >= n std::size_t pos = long_string.size(); boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment(b, pos); } //===================================================================== // Test operator>>= { // case pos == 0 std::size_t pos = 0; { boost::dynamic_bitset<Block> b; Tests::shift_right_assignment(b, pos); } { boost::dynamic_bitset<Block> b(std::string("1010")); Tests::shift_right_assignment(b, pos); } { boost::dynamic_bitset<Block> b(long_string); Tests::shift_right_assignment(b, pos); } } { // test with both multiple and // non multiple of bits_per_block const int how_many = 10; for (int i = 1; i <= how_many; ++i) { std::size_t multiple = i * bits_per_block; std::size_t non_multiple = multiple - 1; boost::dynamic_bitset<Block> b(long_string); Tests::shift_right_assignment(b, multiple); Tests::shift_right_assignment(b, non_multiple); } } { // case pos == size()/2 std::size_t pos = long_string.size() / 2; boost::dynamic_bitset<Block> b(long_string); Tests::shift_right_assignment(b, pos); } { // case pos >= n std::size_t pos = long_string.size(); boost::dynamic_bitset<Block> b(long_string); Tests::shift_right_assignment(b, pos); } //===================================================================== // test b.set() { boost::dynamic_bitset<Block> b; Tests::set_all(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::set_all(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::set_all(b); } //===================================================================== // Test b.set(pos) { // case pos >= b.size() boost::dynamic_bitset<Block> b; Tests::set_one(b, 0, true); } { // case pos < b.size() boost::dynamic_bitset<Block> b(std::string("0")); Tests::set_one(b, 0, true); } { // case pos == b.size() / 2 boost::dynamic_bitset<Block> b(long_string); Tests::set_one(b, long_string.size()/2, true); } //===================================================================== // Test b.reset() { boost::dynamic_bitset<Block> b; Tests::reset_all(b); } { boost::dynamic_bitset<Block> b(std::string("0")); Tests::reset_all(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::reset_all(b); } //===================================================================== // Test b.reset(pos) { // case pos >= b.size() boost::dynamic_bitset<Block> b; Tests::reset_one(b, 0); } { // case pos < b.size() boost::dynamic_bitset<Block> b(std::string("0")); Tests::reset_one(b, 0); } { // case pos == b.size() / 2 boost::dynamic_bitset<Block> b(long_string); Tests::reset_one(b, long_string.size()/2); } //===================================================================== // Test ~b { boost::dynamic_bitset<Block> b; Tests::operator_flip(b); } { boost::dynamic_bitset<Block> b(std::string("1")); Tests::operator_flip(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::operator_flip(b); } //===================================================================== // Test b.flip() { boost::dynamic_bitset<Block> b; Tests::flip_all(b); } { boost::dynamic_bitset<Block> b(std::string("1")); Tests::flip_all(b); } { boost::dynamic_bitset<Block> b(long_string); Tests::flip_all(b); } //===================================================================== // Test b.flip(pos) { // case pos >= b.size() boost::dynamic_bitset<Block> b; Tests::flip_one(b, 0); } { // case pos < b.size() boost::dynamic_bitset<Block> b(std::string("0")); Tests::flip_one(b, 0); } { // case pos == b.size() / 2 boost::dynamic_bitset<Block> b(long_string); Tests::flip_one(b, long_string.size()/2); } }