void test_sequence_with_comparison ( Container &v, Comp comp, typename Container::value_type minE, typename Container::value_type maxE ) { typedef std::pair <typename Container::iterator, typename Container::iterator> Pair; Pair res = ba::minmax_element ( v.begin (), v.end (), comp ); BOOST_CHECK ( *res.first == minE ); BOOST_CHECK ( *res.second == maxE ); std::reverse ( v.begin (), v.end ()); res = ba::minmax_element ( v.begin (), v.end (), comp ); BOOST_CHECK ( *res.first == minE ); BOOST_CHECK ( *res.second == maxE ); std::random_shuffle ( v.begin (), v.end ()); res = ba::minmax_element ( v.begin (), v.end (), comp ); BOOST_CHECK ( *res.first == minE ); BOOST_CHECK ( *res.second == maxE ); // One element int v0 = v[0]; res = ba::minmax_element ( v.begin (), v.begin () + 1, comp ); BOOST_CHECK ( *res.first == v0 ); BOOST_CHECK ( *res.second == v0 ); // Two elements int v1 = v[1]; res = ba::minmax_element ( v.begin (), v.begin () + 2, comp ); if ( comp ( v0, v1 )) { BOOST_CHECK ( *res.first == v0 ); BOOST_CHECK ( *res.second == v1 ); } else { BOOST_CHECK ( *res.first == v1 ); BOOST_CHECK ( *res.second == v0 ); } }
void test_threading_level_cmp() { namespace mt = boost::mpi::threading; BOOST_CHECK(mt::single == mt::single); BOOST_CHECK(mt::funneled == mt::funneled); BOOST_CHECK(mt::serialized == mt::serialized); BOOST_CHECK(mt::multiple == mt::multiple); BOOST_CHECK(mt::single != mt::funneled); BOOST_CHECK(mt::single != mt::serialized); BOOST_CHECK(mt::single != mt::multiple); BOOST_CHECK(mt::funneled != mt::single); BOOST_CHECK(mt::funneled != mt::serialized); BOOST_CHECK(mt::funneled != mt::multiple); BOOST_CHECK(mt::serialized != mt::single); BOOST_CHECK(mt::serialized != mt::funneled); BOOST_CHECK(mt::serialized != mt::multiple); BOOST_CHECK(mt::multiple != mt::single); BOOST_CHECK(mt::multiple != mt::funneled); BOOST_CHECK(mt::multiple != mt::serialized); BOOST_CHECK(mt::single < mt::funneled); BOOST_CHECK(mt::funneled > mt::single); BOOST_CHECK(mt::single < mt::serialized); BOOST_CHECK(mt::serialized > mt::single); BOOST_CHECK(mt::single < mt::multiple); BOOST_CHECK(mt::multiple > mt::single); BOOST_CHECK(mt::funneled < mt::serialized); BOOST_CHECK(mt::serialized > mt::funneled); BOOST_CHECK(mt::funneled < mt::multiple); BOOST_CHECK(mt::multiple > mt::funneled); BOOST_CHECK(mt::serialized < mt::multiple); BOOST_CHECK(mt::multiple > mt::serialized); BOOST_CHECK(mt::single <= mt::single); BOOST_CHECK(mt::single <= mt::funneled); BOOST_CHECK(mt::funneled >= mt::single); BOOST_CHECK(mt::single <= mt::serialized); BOOST_CHECK(mt::serialized >= mt::single); BOOST_CHECK(mt::single <= mt::multiple); BOOST_CHECK(mt::multiple >= mt::single); BOOST_CHECK(mt::funneled <= mt::funneled); BOOST_CHECK(mt::funneled <= mt::serialized); BOOST_CHECK(mt::serialized >= mt::funneled); BOOST_CHECK(mt::funneled <= mt::multiple); BOOST_CHECK(mt::multiple >= mt::funneled); BOOST_CHECK(mt::serialized <= mt::serialized); BOOST_CHECK(mt::serialized <= mt::multiple); BOOST_CHECK(mt::multiple >= mt::serialized); BOOST_CHECK(mt::multiple <= mt::multiple); }
BOOST_FOREACH(const T& v, const_pre_vector) { BOOST_CHECK(v == real_vector[pos++]); }
void test_contains() { RangeList16 rl; rl.merge(0, 5); rl.merge(6, 10); rl.merge(12, 15); rl.merge(21, 26); BOOST_CHECK(rl.size() == 3); BOOST_CHECK(rl.contains(Range16(0))); BOOST_CHECK(rl.contains(Range16(4))); BOOST_CHECK(rl.contains(Range16(6))); BOOST_CHECK(rl.contains(Range16(10))); BOOST_CHECK(!rl.contains(Range16(11))); BOOST_CHECK(rl.contains(Range16(12))); BOOST_CHECK(!rl.contains(Range16(16))); BOOST_CHECK(rl.contains(Range16(21))); BOOST_CHECK(rl.contains(Range16(26))); BOOST_CHECK(!rl.contains(Range16(27))); BOOST_CHECK(rl.getContains(0, 0) != rl.end()); BOOST_CHECK(rl.getContains(5, 5) != rl.end()); BOOST_CHECK(rl.getContains(12, 15) != rl.end()); BOOST_CHECK(rl.getContains(0, 0)->begin() == 0); BOOST_CHECK(rl.getContains(0, 0)->end() == 10); BOOST_CHECK(rl.getContains(0, 5)->begin() == 0); BOOST_CHECK(rl.getContains(0, 5)->end() == 10); BOOST_CHECK(rl.getContains(12, 13)->begin() == 12); BOOST_CHECK(rl.getContains(12, 13)->end() == 15); BOOST_CHECK(rl.getContains(16, 16) == rl.end()); BOOST_CHECK(rl.getContains(12, 20) != rl.end()); BOOST_CHECK(rl.getContains(12, 20)->begin() == 12); BOOST_CHECK(rl.getContains(12, 20)->end() == 15); rl.push(0, 15); BOOST_CHECK(rl.contains(Range16(0))); BOOST_CHECK(rl.contains(Range16(5))); BOOST_CHECK(rl.contains(Range16(11))); BOOST_CHECK(rl.contains(Range16(12))); BOOST_CHECK(rl.contains(Range16(13))); rl.clear(); rl.merge(0, 5); rl.merge(10, 15); rl.merge(20, 25); BOOST_CHECK(rl.contains(0, 2)); BOOST_CHECK(rl.contains(3, 4)); BOOST_CHECK(rl.contains(0, 5)); BOOST_CHECK(rl.contains(5, 6)); BOOST_CHECK(!rl.contains(6, 9)); BOOST_CHECK(rl.contains(6, 10)); BOOST_CHECK(rl.contains(Range16(10))); BOOST_CHECK(rl.contains(10, 10)); BOOST_CHECK(rl.contains(10, 13)); BOOST_CHECK(rl.contains(0, 20)); BOOST_CHECK(!rl.contains(26, 28)); }
void test_merge() { RangeList16 rl; rl.push(0, 5); BOOST_CHECK(rl.size() == 1); // duplicates are allowed BOOST_CHECK(rl.push(0, 1)); BOOST_CHECK(rl.push(5, 5)); BOOST_CHECK(rl.push(0, 100)); BOOST_CHECK(rl.size() == 4); rl.clear(); rl.merge(0, 5); BOOST_CHECK(rl.size() == 1); rl.merge(5, 6); BOOST_CHECK(rl.size() == 1); rl.merge(7, 10); BOOST_CHECK(rl.size() == 1); rl.erase(5, 6); BOOST_CHECK(rl.size() == 2); rl.erase(3, 6); BOOST_CHECK(rl.size() == 2); rl.erase(0, 10); BOOST_CHECK(rl.size() == 0); rl.merge(0, 4); rl.merge(5, 10); rl.merge(4, 4); BOOST_CHECK(rl.size() == 1); }
BOOST_FIXTURE_TEST_CASE(is_a_receivable, F) { logsvc::prot::Disconnect disconnect; BOOST_CHECK(dynamic_cast<logsvc::prot::Receivable*>(&disconnect)); }
void test_more() { RangeList16 r; typedef Range16 RR; typedef RangeList16::CIter CIter; CIter i; /**************************** PART I: Adding *************************/ BOOST_CHECK_NO_THROW(r.merge(RR(5, 10))); i = r.begin(); BOOST_CHECK((*i).begin() == 5); BOOST_CHECK((*i).end() == 10); BOOST_CHECK_NO_THROW(r.merge(RR(20, 30))); i++; BOOST_CHECK((*i).begin() == 20); BOOST_CHECK((*i).end() == 30); BOOST_CHECK(r.size() == 2); // RC_CONTAINS_END BOOST_CHECK_NO_THROW(r.merge(RR(3, 6))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 10); i++; BOOST_CHECK((*i).begin() == 20); BOOST_CHECK((*i).end() == 30); BOOST_CHECK(r.size() == 2); // RC_CONTAINS_FULL - list shouldn't be changed BOOST_CHECK_NO_THROW(r.merge(RR(4, 8))); BOOST_CHECK_NO_THROW(r.merge(RR(3, 4))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 10); i++; BOOST_CHECK((*i).begin() == 20); BOOST_CHECK((*i).end() == 30); BOOST_CHECK(r.size() == 2); // RC_CONTAINS_BEGIN BOOST_CHECK_NO_THROW(r.merge(RR(8, 12))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 12); i++; BOOST_CHECK((*i).begin() == 20); BOOST_CHECK((*i).end() == 30); BOOST_CHECK(r.size() == 2); // RC_BORDER_BEGIN BOOST_CHECK_NO_THROW(r.merge(RR(15, 19))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 12); i++; BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 30); BOOST_CHECK(r.size() == 2); // RC_BORDER_END BOOST_CHECK_NO_THROW(r.merge(RR(31, 35))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 12); i++; BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 35); BOOST_CHECK(r.size() == 2); // RC_BORDER_END BOOST_CHECK_NO_THROW(r.merge(RR(35, 37))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 12); i++; BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 37); BOOST_CHECK(r.size() == 2); // Insert between the two existing ranges BOOST_CHECK_NO_THROW(r.merge(RR(13, 14))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 37); BOOST_CHECK(r.size() == 1); /************************** PART II: Erasing *************************/ // splitting existing range into two BOOST_CHECK_NO_THROW(r.erase(RR(10, 12))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 9); i++; BOOST_CHECK((*i).begin() == 13); BOOST_CHECK((*i).end() == 37); BOOST_CHECK(r.size() == 2); // removing range that doesnt exist BOOST_CHECK_NO_THROW(r.erase(RR(10, 12))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 9); i++; BOOST_CHECK((*i).begin() == 13); BOOST_CHECK((*i).end() == 37); BOOST_CHECK(r.size() == 2); // RC_CONTAINS_END BOOST_CHECK_NO_THROW(r.erase(RR(9, 12))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 8); i++; BOOST_CHECK((*i).begin() == 13); BOOST_CHECK((*i).end() == 37); BOOST_CHECK(r.size() == 2); BOOST_CHECK_NO_THROW(r.erase(RR(30, 40))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 8); i++; BOOST_CHECK((*i).begin() == 13); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 2); // RC_CONTAINS_END BOOST_CHECK_NO_THROW(r.erase(RR(10, 15))); i = r.begin(); BOOST_CHECK((*i).begin() == 3); BOOST_CHECK((*i).end() == 8); i++; BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 2); // RC_AROUND BOOST_CHECK_NO_THROW(r.erase(RR(1, 10))); i = r.begin(); BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 1); // Split again BOOST_CHECK_NO_THROW(r.erase(RR(20, 21))); i = r.begin(); BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 19); i++; BOOST_CHECK((*i).begin() == 22); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 2); // Complex erasing - cuts into two existing ranges BOOST_CHECK_NO_THROW(r.erase(RR(18, 25))); i = r.begin(); BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 17); i++; BOOST_CHECK((*i).begin() == 26); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 2); BOOST_CHECK_NO_THROW(r.merge(RR(16, 20))); // Complex merging - overlap with two existing ranges BOOST_CHECK_NO_THROW(r.merge(RR(18, 28))); i = r.begin(); BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 29); BOOST_CHECK(r.size() == 1); // Range of size 1 BOOST_CHECK_NO_THROW(r.merge(RR(30, 30))); i = r.begin(); BOOST_CHECK(r.size() == 1); BOOST_CHECK((*i).begin() == 16); BOOST_CHECK((*i).end() == 30); // Another range of size 1 BOOST_CHECK_NO_THROW(r.merge(RR(15, 15))); i = r.begin(); BOOST_CHECK(r.size() == 1); BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 30); // Another range of size 1, this time inserting INTO existing range BOOST_CHECK_NO_THROW(r.merge(RR(20, 20))); // List shouldn't have been changed i = r.begin(); BOOST_CHECK(r.size() == 1); BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 30); // Add range of size 1 into random place BOOST_CHECK_NO_THROW(r.merge(RR(10, 10))); i = r.begin(); BOOST_CHECK(r.size() == 2); BOOST_CHECK((*i).begin() == 10); BOOST_CHECK((*i).end() == 10); ++i; BOOST_CHECK((*i).begin() == 15); BOOST_CHECK((*i).end() == 30); }
void empty_set_types_variety_test() { BOOST_CHECK(!(has_key<Set, char>::value)); BOOST_CHECK(!(has_key<Set, int>::value)); BOOST_CHECK(!(has_key<Set, UDT>::value)); BOOST_CHECK(!(has_key<Set, incomplete>::value)); BOOST_CHECK(!(has_key<Set, char const>::value)); BOOST_CHECK(!(has_key<Set, int const>::value)); BOOST_CHECK(!(has_key<Set, UDT const>::value)); BOOST_CHECK(!(has_key<Set, incomplete const>::value)); BOOST_CHECK(!(has_key<Set, int *>::value)); BOOST_CHECK(!(has_key<Set, UDT *>::value)); BOOST_CHECK(!(has_key<Set, incomplete *>::value)); BOOST_CHECK(!(has_key<Set, int &>::value)); BOOST_CHECK(!(has_key<Set, UDT &>::value)); BOOST_CHECK(!(has_key<Set, incomplete &>::value)); }
void set_types_variety_test() { BOOST_CHECK_EQUAL((size<Set>::value), 8); BOOST_CHECK((has_key<Set, char>::value)); BOOST_CHECK((has_key<Set, int const>::value)); BOOST_CHECK((has_key<Set, long *>::value)); BOOST_CHECK((has_key<Set, UDT * const>::value)); BOOST_CHECK((has_key<Set, incomplete>::value)); BOOST_CHECK((has_key<Set, abstract>::value)); BOOST_CHECK((has_key<Set, incomplete volatile &>::value)); BOOST_CHECK((has_key<Set, abstract const &>::value)); BOOST_CHECK(!(has_key<Set, char const>::value)); BOOST_CHECK(!(has_key<Set, int>::value)); BOOST_CHECK(!(has_key<Set, long * const>::value)); BOOST_CHECK(!(has_key<Set, UDT *>::value)); BOOST_CHECK(!(has_key<Set, incomplete const>::value)); BOOST_CHECK(!(has_key<Set, abstract volatile>::value)); BOOST_CHECK(!(has_key<Set, incomplete &>::value)); BOOST_CHECK(!(has_key<Set, abstract &>::value)); }
void test_one () { // Note: The literal values here are tested against directly, careful if you change them: int some_numbers[] = { 1, 1, 2, 3, 5 }; std::vector<int> vi(some_numbers, some_numbers + 5); std::list<int> li(vi.begin(), vi.end ()); int some_letters[] = { 'a', 'q', 'n', 'y', 'n' }; std::vector<char> vc(some_letters, some_letters + 5); BOOST_CHECK (!ba::one_of_equal ( vi, 1 )); BOOST_CHECK (!ba::one_of ( vi, is_<int> ( 1 ))); BOOST_CHECK (!ba::one_of_equal ( vi.begin(), vi.end(), 1 )); BOOST_CHECK (!ba::one_of ( vi.begin(), vi.end(), is_<int> ( 1 ))); BOOST_CHECK (!ba::one_of_equal ( vi, 0 )); BOOST_CHECK (!ba::one_of ( vi, is_<int> ( 0 ))); BOOST_CHECK (!ba::one_of_equal ( vi.begin(), vi.end(), 0 )); BOOST_CHECK (!ba::one_of ( vi.begin(), vi.end(), is_<int> ( 0 ))); BOOST_CHECK ( ba::one_of_equal ( vi, 2 )); BOOST_CHECK ( ba::one_of ( vi, is_<int> ( 2 ))); BOOST_CHECK ( ba::one_of_equal ( vi.begin(), vi.end(), 2 )); BOOST_CHECK ( ba::one_of ( vi.begin(), vi.end(), is_<int> ( 2 ))); // Check for a match at the end BOOST_CHECK ( ba::one_of_equal ( vi, 5 )); BOOST_CHECK ( ba::one_of ( vi, is_<int> ( 5 ))); BOOST_CHECK ( ba::one_of_equal ( vi.begin(), vi.end(), 5 )); BOOST_CHECK ( ba::one_of ( vi.begin(), vi.end(), is_<int> ( 5 ))); BOOST_CHECK ( ba::one_of_equal ( vi.begin() + 1, vi.end(), 1 )); BOOST_CHECK ( ba::one_of ( vi.begin() + 1, vi.end(), is_<int> ( 1 ))); BOOST_CHECK ( ba::one_of_equal ( vc.begin() + 1, vc.begin() + 2, 'q' )); BOOST_CHECK ( ba::one_of ( vc.begin() + 1, vc.begin() + 2, is_<char> ( 'q' ))); BOOST_CHECK (!ba::one_of_equal ( vc, '!' )); BOOST_CHECK (!ba::one_of ( vc, is_<char> ( '!' ))); BOOST_CHECK (!ba::one_of_equal ( vc, 'n' )); BOOST_CHECK (!ba::one_of ( vc, is_<char> ( 'n' ))); // Empty range check BOOST_CHECK (!ba::one_of_equal ( vi.begin(), vi.begin(), 1 )); BOOST_CHECK (!ba::one_of_equal ( vc.begin(), vc.begin(), 'a' )); BOOST_CHECK (!ba::one_of ( vi.begin(), vi.begin(), is_<int> ( 1 ))); BOOST_CHECK (!ba::one_of ( vc.begin(), vc.begin(), is_<char> ( 'a' ))); BOOST_CHECK (!ba::one_of_equal ( li, 1 )); BOOST_CHECK (!ba::one_of ( li, is_<int> ( 1 ))); BOOST_CHECK (!ba::one_of_equal ( li.begin(), li.end(), 1 )); BOOST_CHECK (!ba::one_of ( li.begin(), li.end(), is_<int> ( 1 ))); std::list<int>::iterator l_iter = li.begin (); l_iter++; l_iter++; l_iter++; BOOST_CHECK (!ba::one_of_equal ( li.begin(), l_iter, 1 )); BOOST_CHECK (!ba::one_of ( li.begin(), l_iter, is_<int> ( 1 ))); BOOST_CHECK ( ba::one_of_equal ( li.begin(), l_iter, 2 )); BOOST_CHECK ( ba::one_of ( li.begin(), l_iter, is_<int> ( 2 ))); BOOST_CHECK (!ba::one_of_equal ( li.begin(), l_iter, 3 )); BOOST_CHECK (!ba::one_of ( li.begin(), l_iter, is_<int> ( 3 ))); }
void test() { int *pi = 0; BOOST_CHECK(pi == NULLPTR); }
void TestBoolNotification(const i_property_write<bool> &,boost::optional<bool>,bool cnew) { BOOST_CHECK(cnew); TestBoolNotificationWorked = true; }
void TestPointer(p_member_data_value_class & tcl) { /* Pointers can be assigned, incremented, decremented, and take part in simple arithmetic. */ prop_member_data < int *, p_member_data_class, &p_member_data_class::p_pointer, notification_boost_function > p_loc_pointer(pmd_gl_pointer,&p_gl_iarray[7]); prop_member_data < int *, p_member_data_class, &p_member_data_class::p_pointer_2 > p_loc_pointer2(pmd_gl_pointer,&p_gl_iarray[4]); BOOST_CHECK_EQUAL(*p_loc_pointer,7783); p_loc_pointer = &p_gl_iarray[6]; BOOST_CHECK_EQUAL(*p_loc_pointer,230); BOOST_CHECK_EQUAL(p_loc_pointer - p_loc_pointer2,2); p_loc_pointer += 4; BOOST_CHECK_EQUAL(*p_loc_pointer,12); p_loc_pointer.fun = &TestPointerNotification; p_loc_pointer -= 2; BOOST_CHECK_EQUAL(*p_loc_pointer,22675); BOOST_CHECK(TestPointerNotificationWorked); p_gl_pointer_ntf = &gld_int; *p_gl_pointer_ntf = 489; BOOST_CHECK_EQUAL(*p_gl_pointer_ntf,489); p_member_data_value_class::p_st_pointer = &p_member_data_value_class::p_st_iarray[5]; BOOST_CHECK_EQUAL(*p_member_data_value_class::p_st_pointer,53); ++p_member_data_value_class::p_st_pointer; BOOST_CHECK_EQUAL(*p_member_data_value_class::p_st_pointer,3456); BOOST_CHECK_EQUAL(*tcl.p_pointer,34); tcl.p_pointer -= 2; BOOST_CHECK_EQUAL(*tcl.p_pointer,13562); --tcl.p_pointer; BOOST_CHECK_EQUAL(*tcl.p_pointer,56); tcl.p_pointer += 11; BOOST_CHECK_EQUAL(*(tcl.p_pointer--),3452); BOOST_CHECK_EQUAL(*tcl.p_pointer,789); p_member_data_value_class::p_st_pointer -= 4; BOOST_CHECK_EQUAL(*(p_member_data_value_class::p_st_pointer++),5347); BOOST_CHECK_EQUAL(*p_member_data_value_class::p_st_pointer,369); }
void TestInt(p_member_data_value_class & tcl) { /* Integers can be tested with the full range of integer operations. */ prop_member_data < int, p_member_data_class, &p_member_data_class::p_data_int, notification_boost_function > p_loc_int(tcl.pmd_int,563); p_gl_int = 34662; BOOST_CHECK_EQUAL(p_gl_int,34662); p_member_data_value_class::p_st_int = 34; BOOST_CHECK_EQUAL(p_member_data_value_class::p_st_int,34); tcl.p_int = 44; tcl.p_int += 12; BOOST_CHECK_EQUAL(tcl.p_int,56); tcl.p_int -= 16; BOOST_CHECK_EQUAL(tcl.p_int,40); ++tcl.p_int; BOOST_CHECK_EQUAL(tcl.p_int,41); ++tcl.p_int; ++tcl.p_int; --tcl.p_int; BOOST_CHECK_EQUAL(tcl.p_int,42); tcl.p_int /= 3; BOOST_CHECK_EQUAL(tcl.p_int,14); tcl.p_int *= 5; BOOST_CHECK_EQUAL(tcl.p_int,70); int il1(p_loc_int++); BOOST_CHECK_EQUAL(il1,563); BOOST_CHECK_EQUAL(p_loc_int,564); p_loc_int >>= 2; BOOST_CHECK_EQUAL(p_loc_int,141); p_loc_int -= 81; p_loc_int <<= 3; BOOST_CHECK_EQUAL(p_loc_int,480); il1 = --p_loc_int; BOOST_CHECK_EQUAL(il1,479); p_loc_int -= 6; BOOST_CHECK_EQUAL(p_loc_int,473); p_loc_int |= 0x0da; BOOST_CHECK_EQUAL(p_loc_int,475); p_loc_int &= 0x076; BOOST_CHECK_EQUAL(p_loc_int,82); p_loc_int.fun = &TestIntegerNotification; p_loc_int = 23611; BOOST_CHECK(TestIntegerNotificationWorked); tcl.p_int ^= 57; }
static void CheckCompare(const int64_t& num1, const int64_t& num2) { const CBigNum bignum1(num1); const CBigNum bignum2(num2); const CScriptNum scriptnum1(num1); const CScriptNum scriptnum2(num2); BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == scriptnum1)); BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != scriptnum1)); BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < scriptnum1)); BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > scriptnum1)); BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= scriptnum1)); BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= scriptnum1)); BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == num1)); BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != num1)); BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < num1)); BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > num1)); BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= num1)); BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= num1)); BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == scriptnum2)); BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != scriptnum2)); BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < scriptnum2)); BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > scriptnum2)); BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= scriptnum2)); BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= scriptnum2)); BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == num2)); BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != num2)); BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < num2)); BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > num2)); BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= num2)); BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= num2)); }
void int_char_set_test() { BOOST_CHECK_EQUAL((size<Set>::value), 2); BOOST_CHECK(!(empty<Set>::value)); BOOST_CHECK((std::is_same<typename clear<Set>::type, set<>>::value)); BOOST_CHECK((std::is_same<typename at<Set, int>::type, int>::value)); BOOST_CHECK((std::is_same<typename at<Set, char>::type, char>::value)); BOOST_CHECK((has_key<Set, char>::value)); BOOST_CHECK(!(has_key<Set, long>::value)); typedef typename order<Set, int>::type o1; typedef typename order<Set, char>::type o2; typedef typename order<Set, long>::type o3; BOOST_CHECK(!(std::is_same<o1, void_>::value)); BOOST_CHECK(!(std::is_same<o2, void_>::value)); BOOST_CHECK((std::is_same<o3, void_>::value)); BOOST_CHECK(!(std::is_same<o1, o2>::value)); typedef typename begin<Set>::type first; typedef typename end<Set>::type last; BOOST_CHECK_EQUAL((distance<first, last>::value), 2); BOOST_CHECK((contains<Set, int>::value)); BOOST_CHECK((contains<Set, char>::value)); }
static inline void base_test(Geometry1 const& geometry1, Geometry2 const& geometry2, MultiLineString const& mls_int1, MultiLineString const& mls_int2, std::string const& case_id, double tolerance, bool test_vector_and_deque = false) { static bool vector_deque_already_tested = false; typedef typename boost::range_value<MultiLineString>::type LineString; typedef std::vector<LineString> linestring_vector; typedef std::deque<LineString> linestring_deque; MultiLineString mls_output; linestring_vector ls_vector_output; linestring_deque ls_deque_output; bg::intersection(geometry1, geometry2, mls_output); BOOST_CHECK_MESSAGE( equals::apply(mls_int1, mls_output, tolerance) || equals::apply(mls_int2, mls_output, tolerance), "case id: " << case_id << ", intersection L/L: " << bg::wkt(geometry1) << " " << bg::wkt(geometry2) << " -> Expected: " << bg::wkt(mls_int1) << " or: " << bg::wkt(mls_int2) << " computed: " << bg::wkt(mls_output) ); set_operation_output("intersection", case_id, geometry1, geometry2, mls_output); #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << "Geometry #1: " << bg::wkt(geometry1) << std::endl; std::cout << "Geometry #2: " << bg::wkt(geometry2) << std::endl; std::cout << "intersection : " << bg::wkt(mls_output) << std::endl; std::cout << "expected intersection : " << bg::wkt(mls_int1) << " or: " << bg::wkt(mls_int2) << std::endl; std::cout << std::endl; std::cout << "************************************" << std::endl; std::cout << std::endl; std::cout << std::endl; #endif if ( !vector_deque_already_tested && test_vector_and_deque ) { vector_deque_already_tested = true; #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << std::endl; std::cout << "Testing with vector and deque as output container..." << std::endl; #endif bg::intersection(geometry1, geometry2, ls_vector_output); bg::intersection(geometry1, geometry2, ls_deque_output); BOOST_CHECK(multilinestring_equals < false >::apply(mls_int1, ls_vector_output, tolerance)); BOOST_CHECK(multilinestring_equals < false >::apply(mls_int1, ls_deque_output, tolerance)); #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << "Done!" << std::endl << std::endl; #endif } // check the intersection where the order of the two // geometries is reversed bg::clear(mls_output); bg::intersection(geometry2, geometry1, mls_output); BOOST_CHECK_MESSAGE( equals::apply(mls_int1, mls_output, tolerance) || equals::apply(mls_int2, mls_output, tolerance), "case id: " << case_id << ", intersection L/L: " << bg::wkt(geometry1) << " " << bg::wkt(geometry2) << " -> Expected: " << bg::wkt(mls_int1) << " or: " << bg::wkt(mls_int2) << " computed: " << bg::wkt(mls_output) ); #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << "Geometry #1: " << bg::wkt(geometry2) << std::endl; std::cout << "Geometry #2: " << bg::wkt(geometry1) << std::endl; std::cout << "intersection : " << bg::wkt(mls_output) << std::endl; std::cout << "expected intersection : " << bg::wkt(mls_int1) << " or: " << bg::wkt(mls_int2) << std::endl; std::cout << std::endl; std::cout << "************************************" << std::endl; std::cout << std::endl; std::cout << std::endl; #endif }
template_whose_default_ctor_should_be_used(const template_whose_default_ctor_should_be_used &) { BOOST_CHECK(!"This copy constructor should not be used while swapping!"); throw copy_ctor_exception(); }
BOOST_FIXTURE_TEST_CASE(is_final_message, F) { logsvc::prot::Disconnect disconnect; BOOST_CHECK(disconnect.is_final_message()); }
class_whose_explicit_ctor_should_be_used(const class_whose_explicit_ctor_should_be_used &) { BOOST_CHECK(!"This copy constructor should not be used while swapping!"); throw copy_ctor_exception(); }
void test_base() { Range16 r(0, 5); BOOST_CHECK(r.length() == 6); BOOST_CHECK(r.begin() == 0); BOOST_CHECK(r.end() == 5); BOOST_CHECK(r.contains(0)); BOOST_CHECK(r.contains(3)); BOOST_CHECK(r.contains(5)); BOOST_CHECK(!r.contains(6)); BOOST_CHECK(!r.contains(100)); BOOST_CHECK_THROW(r.begin(6), std::exception); BOOST_CHECK_NO_THROW(r.begin(5)); BOOST_CHECK(r.length() == 1); BOOST_CHECK_NO_THROW(r.end(10)); BOOST_CHECK(r.begin() == 5); BOOST_CHECK(r.end() == 10); BOOST_CHECK(r.length() == 6); Range16 r1(0, 5); Range16 r2(0, 2); BOOST_CHECK(r1.contains(r2)); BOOST_CHECK(r1.contains(0, 0)); BOOST_CHECK(r1.contains(Range16(5, 5))); BOOST_CHECK(r1.contains(5, 6)); BOOST_CHECK(!r1.contains(6, 6)); BOOST_CHECK(r1.containsFull(r2)); BOOST_CHECK(r1.containsFull(0, 4)); BOOST_CHECK(r1.containsFull(0, 5)); BOOST_CHECK(!r1.containsFull(0, 6)); BOOST_CHECK(r1.containsFull(5, 5)); BOOST_CHECK(r1.containsFull(Range16(1, 5))); BOOST_CHECK(!r1.containsFull(Range16(6, 6))); BOOST_CHECK(!r1.containsFull(5, 10)); Range16 r3(20, 30); Range16 r4( 3, 10); BOOST_CHECK(!r3.contains(r4)); BOOST_CHECK(!r3.borders(r4)); // test comparison operators BOOST_CHECK(r1 != r2); BOOST_CHECK(r2 != r1); BOOST_CHECK(r3 != r4); // BOOST_CHECK(r3 > r4); // BOOST_CHECK(r4 < r3); }
base_class_with_forbidden_assignment & operator=(const base_class_with_forbidden_assignment &) { BOOST_CHECK(!"The assignment should not be used while swapping!"); throw assignment_exception(); }
void test_even_more() { RangeList16 rl; rl.merge(0, 100); rl.erase(0, 50); BOOST_CHECK(rl.size() == 1); BOOST_CHECK(rl.front().begin() == 51); BOOST_CHECK(rl.front().end() == 100); rl.clear(); rl.merge(0, 29); rl.merge(34, 50); rl.merge(53, 100); BOOST_CHECK(rl.getContains(30, 33) == rl.end()); BOOST_CHECK(rl.getContains(30, 60)->begin() == 34); BOOST_CHECK(rl.getContains(30, 60)->end() == 50); BOOST_CHECK(rl.getContains(30, 100) != rl.end()); rl.erase(rl.getContains(30, 60)); BOOST_CHECK(rl.getContains(30, 60)->begin() == 53); BOOST_CHECK(rl.getContains(30, 60)->end() == 100); rl.erase(rl.getContains(55, 55)); BOOST_CHECK(rl.size() == 1); BOOST_CHECK(rl.begin()->begin() == 0); BOOST_CHECK(rl.begin()->end() == 29); RangeList32 rl2; rl2.merge(0ul, 1044496385ul); rl2.merge(1044496387ul, 4294967290ul); BOOST_CHECK(rl2.contains(Range32(123567ul))); BOOST_CHECK(rl2.contains(Range32(1044496385ul))); BOOST_CHECK(rl2.contains(Range32(123123245ul))); BOOST_CHECK(rl2.contains(Range32(1044496384ul))); BOOST_CHECK(rl2.contains(Range32(1044496387ul))); BOOST_CHECK(rl2.contains(Range32(2669731838ul))); BOOST_CHECK(rl2.contains(Range32(2669731840ul))); BOOST_CHECK(rl2.contains(Range32(2669731700ul))); BOOST_CHECK(!rl2.contains(Range32(1044496386ul))); }
class_whose_default_ctor_should_not_be_used() { BOOST_CHECK(!"This default constructor should not be used while swapping!"); throw default_ctor_exception(); }
void verifyWellState(const std::string& rst_filename, Opm::EclipseGridConstPtr ecl_grid, Opm::ScheduleConstPtr schedule) { well_info_type * well_info = well_info_alloc(ecl_grid->c_ptr()); well_info_load_rstfile(well_info, rst_filename.c_str(), false); //Verify numwells int numwells = well_info_get_num_wells(well_info); BOOST_CHECK(numwells == (int)schedule->numWells()); std::vector<Opm::WellConstPtr> wells = schedule->getWells(); for (int i = 0; i < numwells; ++i) { //Verify wellnames const char * wellname = well_info_iget_well_name(well_info, i); Opm::WellConstPtr well = wells.at(i); BOOST_CHECK(wellname == well->name()); // Verify well-head position data well_ts_type * well_ts = well_info_get_ts(well_info , wellname); well_state_type * well_state = well_ts_iget_state(well_ts, 0); const well_conn_type * well_head = well_state_get_wellhead(well_state, ECL_GRID_GLOBAL_GRID); BOOST_CHECK(well_conn_get_i(well_head) == well->getHeadI()); BOOST_CHECK(well_conn_get_j(well_head) == well->getHeadJ()); for (int j = 0; j < well_ts_get_size(well_ts); ++j) { well_state = well_ts_iget_state(well_ts, j); //Verify welltype int ert_well_type = well_state_get_type(well_state); WellType welltype = well->isProducer(j) ? PRODUCER : INJECTOR; Opm::WellInjector::TypeEnum injectortype = well->getInjectionProperties(j).injectorType; int ecl_converted_welltype = Opm::EclipseWriter::eclipseWellTypeMask(welltype, injectortype); int ert_converted_welltype = well_state_translate_ecl_type_int(ecl_converted_welltype); BOOST_CHECK(ert_well_type == ert_converted_welltype); //Verify wellstatus int ert_well_status = well_state_is_open(well_state) ? 1 : 0; Opm::WellCommon::StatusEnum status = well->getStatus(j); int wellstatus = Opm::EclipseWriter::eclipseWellStatusMask(status); BOOST_CHECK(ert_well_status == wellstatus); //Verify number of completion connections const well_conn_collection_type * well_connections = well_state_get_global_connections( well_state ); size_t num_wellconnections = well_conn_collection_get_size(well_connections); int report_nr = well_state_get_report_nr(well_state); Opm::CompletionSetConstPtr completions_set = well->getCompletions((size_t)report_nr); BOOST_CHECK(num_wellconnections == completions_set->size()); //Verify coordinates for each completion connection for (size_t k = 0; k < num_wellconnections; ++k) { const well_conn_type * well_connection = well_conn_collection_iget_const(well_connections , k); Opm::CompletionConstPtr completion = completions_set->get(k); BOOST_CHECK(well_conn_get_i(well_connection) == completion->getI()); BOOST_CHECK(well_conn_get_j(well_connection) == completion->getJ()); BOOST_CHECK(well_conn_get_k(well_connection) == completion->getK()); } } } well_info_free(well_info); }
static inline void base_test(std::string const& ENABLE_IF_DEBUG(header), G1 const& g1, G2 const& g2, DistanceType const& expected_distance, ComparableDistanceType const& expected_comparable_distance, Strategy const& strategy, bool is_finite) { typedef typename bg::default_distance_result < G1, G2 >::type default_distance_result; typedef typename bg::strategy::distance::services::return_type < Strategy, G1, G2 >::type distance_result_from_strategy; static const bool same_regular = boost::is_same < default_distance_result, distance_result_from_strategy >::type::value; BOOST_CHECK( same_regular ); typedef typename bg::default_comparable_distance_result < G1, G2 >::type default_comparable_distance_result; typedef typename bg::strategy::distance::services::return_type < typename bg::strategy::distance::services::comparable_type < Strategy >::type, G1, G2 >::type comparable_distance_result_from_strategy; static const bool same_comparable = boost::is_same < default_comparable_distance_result, comparable_distance_result_from_strategy >::type::value; BOOST_CHECK( same_comparable ); // check distance with default strategy default_distance_result dist_def = bg::distance(g1, g2); check_equal < default_distance_result >::apply(dist_def, expected_distance, is_finite); // check distance with passed strategy distance_result_from_strategy dist = bg::distance(g1, g2, strategy); check_equal < default_distance_result >::apply(dist, expected_distance, is_finite); // check comparable distance with default strategy default_comparable_distance_result cdist_def = bg::comparable_distance(g1, g2); check_equal < default_comparable_distance_result >::apply(cdist_def, expected_comparable_distance, is_finite); // check comparable distance with passed strategy comparable_distance_result_from_strategy cdist = bg::comparable_distance(g1, g2, strategy); check_equal < default_comparable_distance_result >::apply(cdist, expected_comparable_distance, is_finite); #ifdef BOOST_GEOMETRY_TEST_DEBUG std::cout << string_from_type<typename bg::coordinate_type<Geometry1>::type>::name() << string_from_type<typename bg::coordinate_type<Geometry2>::type>::name() << " -> " << string_from_type<default_distance_result>::name() << string_from_type<default_comparable_distance_result>::name() << std::endl; std::cout << "distance" << header << " (def. strategy) = " << dist_def << " ; " << "distance" << header <<" (passed strategy) = " << dist << " ; " << "comp. distance" << header <<" (def. strategy) = " << cdist_def << " ; " << "comp. distance" << header <<" (passed strategy) = " << cdist << std::endl; #endif }
void test_dataitem_type(DataItem::ValueType type, const T &def, const T &val) { DataItem value; BOOST_CHECK(value.get<T>() == def); BOOST_CHECK(static_cast<T *>(value) == nullptr); value = val; BOOST_CHECK(value.getType() == type); BOOST_CHECK(value.get<T>() == val); BOOST_CHECK(static_cast<T *>(value) != nullptr); Buffer buffer; BOOST_CHECK(value.write(buffer)); buffer.seekToBegin(); DataItem valueCheck; BOOST_CHECK(valueCheck.read(buffer)); BOOST_CHECK(valueCheck.getType() == type); BOOST_CHECK(value == valueCheck); BOOST_CHECK(valueCheck.get<T>() == val); BOOST_CHECK(static_cast<T *>(valueCheck) != nullptr); value.clear(); BOOST_CHECK(value.isNull()); BOOST_CHECK(value.getType() == DataItem::vt_null); BOOST_CHECK(value == DataItem::EMPTY); }
BOOST_FIXTURE_TEST_CASE(Fixturetest_case1, F) { BOOST_CHECK(i == 1); ++i; }
BOOST_REVERSE_FOREACH(const T& v, const_pre_vector) { BOOST_CHECK(v == real_vector[--pos]); }
void test_one () { std::pair<const int &, const int &> res1 = ba::minmax ( 5, 15 ); std::pair<const int &, const int &> res2 = ba::minmax ( 15, 5 ); BOOST_CHECK ( res1 == res2 ); }