BOOST_FIXTURE_TEST_CASE(sphereTest_returns_result, WithSphere) { const auto result = hitTest.sphereTest({0.f, 0.f, 0.f}, 1.f); BOOST_CHECK_EQUAL(result.size(), 1); }
void test_round_trip() { std::cout << std::hex; std::cerr << std::hex; for(unsigned i = 0; i < 1000; ++i) { T val = generate_random<T>(); std::vector<unsigned char> cv; export_bits(val, std::back_inserter(cv), 8); T newval; import_bits(newval, cv.begin(), cv.end()); BOOST_CHECK_EQUAL(val, newval); // Should get the same value if we reverse the bytes: std::reverse(cv.begin(), cv.end()); newval = 0; import_bits(newval, cv.begin(), cv.end(), 8, false); BOOST_CHECK_EQUAL(val, newval); // Also try importing via pointers as these may memcpy: newval = 0; import_bits(newval, &cv[0], &cv[0] + cv.size(), 8, false); BOOST_CHECK_EQUAL(val, newval); cv.clear(); export_bits(val, std::back_inserter(cv), 8, false); import_bits(newval, cv.begin(), cv.end(), 8, false); BOOST_CHECK_EQUAL(val, newval); std::reverse(cv.begin(), cv.end()); newval = 0; import_bits(newval, cv.begin(), cv.end(), 8, true); BOOST_CHECK_EQUAL(val, newval); std::vector<boost::uintmax_t> bv; export_bits(val, std::back_inserter(bv), std::numeric_limits<boost::uintmax_t>::digits); import_bits(newval, bv.begin(), bv.end()); BOOST_CHECK_EQUAL(val, newval); // Should get the same value if we reverse the values: std::reverse(bv.begin(), bv.end()); newval = 0; import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<boost::uintmax_t>::digits, false); BOOST_CHECK_EQUAL(val, newval); // Also try importing via pointers as these may memcpy: newval = 0; import_bits(newval, &bv[0], &bv[0] + bv.size(), std::numeric_limits<boost::uintmax_t>::digits, false); BOOST_CHECK_EQUAL(val, newval); bv.clear(); export_bits(val, std::back_inserter(bv), std::numeric_limits<boost::uintmax_t>::digits, false); import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<boost::uintmax_t>::digits, false); BOOST_CHECK_EQUAL(val, newval); // // Try with an unconventional number of bits, to model some machine with guard bits: // bv.clear(); export_bits(val, std::back_inserter(bv), std::numeric_limits<boost::uintmax_t>::digits - 3); import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<boost::uintmax_t>::digits - 3); BOOST_CHECK_EQUAL(val, newval); bv.clear(); export_bits(val, std::back_inserter(bv), std::numeric_limits<boost::uintmax_t>::digits - 3, false); import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<boost::uintmax_t>::digits - 3, false); BOOST_CHECK_EQUAL(val, newval); cv.clear(); export_bits(val, std::back_inserter(cv), 6); import_bits(newval, cv.begin(), cv.end(), 6); BOOST_CHECK_EQUAL(val, newval); cv.clear(); export_bits(val, std::back_inserter(cv), 6, false); import_bits(newval, cv.begin(), cv.end(), 6, false); BOOST_CHECK_EQUAL(val, newval); test_round_trip_neg(val, boost::mpl::bool_<std::numeric_limits<T>::is_signed>()); } }
void test_element_to_odil( TInputType const & source_value, TInputType const & (odil::Element::*getter)() const) { DcmTag const source_tag(0xdead, 0xbeef, VEVR); TElementType source(source_tag); if(typeid(TInputType) == typeid(odil::Value::Strings) || VEVR == EVR_IS || VEVR == EVR_DS) { OFString value; if(!source_value.empty()) { auto const last_it = --source_value.end(); auto it = source_value.begin(); while(it != last_it) { std::ostringstream stream; stream << *it; value += stream.str().c_str(); value += "\\"; ++it; } std::ostringstream stream; stream << *last_it; value += stream.str().c_str(); } source.putOFStringArray(value); } else { for(unsigned int i=0; i<source_value.size(); ++i) { auto const & item = source_value[i]; odil::dcmtk::ElementAccessor<typename odil::dcmtk::VRTraits<VEVR>::ValueType>::element_set( source, item, i); } } odil::Element const destination = odil::dcmtk::convert(&source); BOOST_CHECK(VVR == destination.vr); BOOST_CHECK_EQUAL(source.getVM(), destination.size()); for(std::size_t i=0; i<destination.size(); ++i) { typedef typename odil::dcmtk::VRTraits<VEVR>::ValueType ValueType; if(typeid(TInputType) == typeid(odil::Value::Reals)) { compare<ValueType>( odil::dcmtk::ElementAccessor<ValueType>::element_get(source, i), (destination.*getter)()[i]); } else { BOOST_CHECK_EQUAL( odil::dcmtk::ElementAccessor<ValueType>::element_get(source, i), (destination.*getter)()[i]); } } }
void handle_error(boost::system::error_code const& error, int expected_error, std::string const& expected_message) { BOOST_CHECK_EQUAL(expected_error, error.value()); BOOST_CHECK_EQUAL(expected_message, error.message()); }
void check_controls_epoch3( struct WellControls ** ctrls) { // The new producer const struct WellControls * ctrls1 = ctrls[1]; // Note: controls include default (1 atm) BHP control. BOOST_CHECK_EQUAL( 6 , well_controls_get_num(ctrls1)); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_to_string4, mp_int_type, mp_int_types) { const mp_int_type x("76484675"); const std::string s = x.template to_string<std::string>(std::ios::oct); BOOST_CHECK_EQUAL(s, "443610103"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_to_string11, mp_int_type, mp_int_types) { const mp_int_type x("0x12471fa56d6"); const std::string s = x.template to_string<std::string>(); BOOST_CHECK_EQUAL(s, "1256042682070"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(constructor,T,full_test_types) { typedef T value_type; value_type queue; BOOST_CHECK_EQUAL(queue.size(),0.); BOOST_CHECK_EQUAL(queue.top(),0.); }
static void test_control() { //std::cerr << __func__ << ": " << typeid(T).name() << ".\n"; T control; const std::unique_ptr<gui2::iterator::twalker_> visitor(control.create_walker()); BOOST_REQUIRE_NE(visitor.get(), static_cast<void*>(nullptr)); /***** INITIAL STATE *****/ BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::widget), false); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::grid), true); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), true); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::widget), &control); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::grid), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); /***** VISITING WIDGET *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::widget), gui2::iterator::twalker_::invalid); BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::grid), gui2::iterator::twalker_::fail); BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::fail); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::widget), true); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::grid), true); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), true); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::widget), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::grid), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); /***** POST END *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::widget), gui2::iterator::twalker_::fail); }
void test_math_scalar_copy_ctr_TV(void) { auto s1 = eagine::math::scalar<T, 1, V>::make(1); eagine::math::scalar<T, 1, V> s1c = s1; BOOST_CHECK_EQUAL(s1c, T(1)); auto s2 = eagine::math::scalar<T, 2, V>::make(2); eagine::math::scalar<T, 2, V> s2c = s2; BOOST_CHECK_EQUAL(s2c, T(2)); auto s3 = eagine::math::scalar<T, 3, V>::make(3); eagine::math::scalar<T, 3, V> s3c = s3; BOOST_CHECK_EQUAL(s3c, T(3)); auto s4 = eagine::math::scalar<T, 4, V>::make(4); eagine::math::scalar<T, 4, V> s4c = s4; BOOST_CHECK_EQUAL(s4c, T(4)); auto s5 = eagine::math::scalar<T, 5, V>::make(5); eagine::math::scalar<T, 5, V> s5c = s5; BOOST_CHECK_EQUAL(s5c, T(5)); auto s6 = eagine::math::scalar<T, 6, V>::make(6); eagine::math::scalar<T, 6, V> s6c = s6; BOOST_CHECK_EQUAL(s6c, T(6)); auto s7 = eagine::math::scalar<T, 7, V>::make(7); eagine::math::scalar<T, 7, V> s7c = s7; BOOST_CHECK_EQUAL(s7c, T(7)); auto s8 = eagine::math::scalar<T, 8, V>::make(8); eagine::math::scalar<T, 8, V> s8c = s8; BOOST_CHECK_EQUAL(s8c, T(8)); auto s11 = eagine::math::scalar<T,11, V>::make(11); eagine::math::scalar<T,11, V> s11c = s11; BOOST_CHECK_EQUAL(s11c, T(11)); auto s17 = eagine::math::scalar<T,17, V>::make(17); eagine::math::scalar<T,17, V> s17c = s17; BOOST_CHECK_EQUAL(s17c, T(17)); auto s23 = eagine::math::scalar<T,23, V>::make(23); eagine::math::scalar<T,23, V> s23c = s23; BOOST_CHECK_EQUAL(s23c, T(23)); }
void test_math_scalar_make_and_conv_TV(void) { auto s1 = eagine::math::scalar<T, 1, V>::make(1); T s1v = s1; BOOST_CHECK_EQUAL(s1v, T(1)); auto s2 = eagine::math::scalar<T, 2, V>::make(2); T s2v = s2; BOOST_CHECK_EQUAL(s2v, T(2)); auto s3 = eagine::math::scalar<T, 3, V>::make(3); T s3v = s3; BOOST_CHECK_EQUAL(s3v, T(3)); auto s4 = eagine::math::scalar<T, 4, V>::make(4); T s4v = s4; BOOST_CHECK_EQUAL(s4v, T(4)); auto s5 = eagine::math::scalar<T, 5, V>::make(5); T s5v = s5; BOOST_CHECK_EQUAL(s5v, T(5)); auto s6 = eagine::math::scalar<T, 6, V>::make(6); T s6v = s6; BOOST_CHECK_EQUAL(s6v, T(6)); auto s7 = eagine::math::scalar<T, 7, V>::make(7); T s7v = s7; BOOST_CHECK_EQUAL(s7v, T(7)); auto s8 = eagine::math::scalar<T, 8, V>::make(8); T s8v = s8; BOOST_CHECK_EQUAL(s8v, T(8)); auto s11 = eagine::math::scalar<T,11, V>::make(11); T s11v = s11; BOOST_CHECK_EQUAL(s11v, T(11)); auto s17 = eagine::math::scalar<T,17, V>::make(17); T s17v = s17; BOOST_CHECK_EQUAL(s17v, T(17)); auto s23 = eagine::math::scalar<T,23, V>::make(23); T s23v = s23; BOOST_CHECK_EQUAL(s23v, T(23)); }
BOOST_FIXTURE_TEST_CASE(test_result_contains_object, WithSphere) { const auto result = hitTest.sphereTest({0.f, 0.f, 0.f}, 1.f); BOOST_ASSERT(result.size() == 1); BOOST_CHECK_EQUAL(result[0].object, object); }
BOOST_FIXTURE_TEST_CASE(result_contains_body, WithSphere) { const auto result = hitTest.sphereTest({0.f, 0.f, 0.f}, 1.f); BOOST_ASSERT(result.size() == 1); BOOST_CHECK_EQUAL(result[0].body, target.get()); }
BOOST_FIXTURE_TEST_CASE(boxTest_returns_result, WithSphere) { auto sphereBoundingBoxEdge = glm::vec3{ 0.f, 0.f, shape.getRadius() }; const auto result = hitTest.boxTest(sphereBoundingBoxEdge, {0.01f, 0.01f, 0.01f}); BOOST_CHECK_EQUAL(result.size(), 1); }
BOOST_AUTO_TEST_CASE_TEMPLATE(assign3, mp_int_type, mp_int_types) { mp_int_type x("-564897123123456456789789789897"); x.assign("1234567000000000000000000000000077", std::ios::oct); BOOST_CHECK_EQUAL(x, "01234567000000000000000000000000077"); }
static void test_grid() { /* An empty grid behaves the same as a control so test here. */ test_control<gui2::tgrid>(); //std::cerr << __func__ << ": Detailed test.\n"; /* Test the child part here. */ gui2::tgrid grid(2 ,2); add_widget(grid, new gui2::tlabel(), "(1,1)", 0, 0); add_widget(grid, new gui2::tlabel(), "(1,2)", 0, 1); add_widget(grid, new gui2::tlabel(), "(2,1)", 1, 0); add_widget(grid, new gui2::tlabel(), "(2,2)", 1, 1); const std::unique_ptr<gui2::iterator::twalker_> visitor(grid.create_walker()); /***** LABEL 1,1 *****/ BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(1,1)"); /***** LABEL 2,1 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(2,1)"); /***** LABEL 1,2 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(1,2)"); /***** LABEL 2,2 *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::valid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), false); BOOST_REQUIRE_NE(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child)->id(), "(2,2)"); /***** END *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::invalid); BOOST_CHECK_EQUAL(visitor->at_end(gui2::iterator::twalker_::child), true); BOOST_CHECK_EQUAL(visitor->get(gui2::iterator::twalker_::child), static_cast<void*>(nullptr)); /***** POST END *****/ BOOST_CHECK_EQUAL(visitor->next(gui2::iterator::twalker_::child), gui2::iterator::twalker_::fail); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_to_string2, mp_int_type, mp_int_types) { const mp_int_type x("12345678901234567890"); const std::string s = x.template to_string<std::string>(); BOOST_CHECK_EQUAL(s, "12345678901234567890"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign2, mp_int_type, mp_int_types) { mp_int_type x; x = "0xabcdef123456789"; BOOST_CHECK_EQUAL(x, "0xabcdef123456789"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_to_string5, mp_int_type, mp_int_types) { const mp_int_type x("1024"); const std::string s = x.template to_string<std::string>(std::ios::oct); BOOST_CHECK_EQUAL(s, "2000"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign3, mp_int_type, mp_int_types) { mp_int_type x; x = "012345676543210000001"; BOOST_CHECK_EQUAL(x, "012345676543210000001"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign1, mp_int_type, mp_int_types) { mp_int_type x; x = "269513460"; BOOST_CHECK_EQUAL(x, "269513460"); }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign4, mp_int_type, mp_int_types) { mp_int_type x; x = "0"; BOOST_CHECK_EQUAL(!x, true); }
void check_controls_epoch1( struct WellControls ** ctrls) { // The injector { const struct WellControls * ctrls0 = ctrls[0]; BOOST_CHECK_EQUAL( 3 , well_controls_get_num(ctrls0)); // The number of controls for the injector == 3?? BOOST_CHECK_EQUAL( SURFACE_RATE , well_controls_iget_type(ctrls0 , 0 )); BOOST_CHECK_EQUAL( RESERVOIR_RATE , well_controls_iget_type(ctrls0 , 1 )); BOOST_CHECK_EQUAL( BHP , well_controls_iget_type(ctrls0 , 2 )); // The different targets BOOST_CHECK_CLOSE( 10.0 / 86400 , well_controls_iget_target(ctrls0 , 0) , 0.001); BOOST_CHECK_CLOSE( 20.0 / 86400 , well_controls_iget_target(ctrls0 , 1) , 0.001); BOOST_CHECK_CLOSE( 40 * 100000 , well_controls_iget_target(ctrls0 , 2) , 0.001); // Which control is active BOOST_CHECK_EQUAL( 1 , well_controls_get_current(ctrls0)); { const double * distr = well_controls_iget_distr( ctrls0 , 1 ); BOOST_CHECK_EQUAL( 1 , distr[0] ); // Water BOOST_CHECK_EQUAL( 0 , distr[1] ); // Oil BOOST_CHECK_EQUAL( 0 , distr[2] ); // Gas } } // The producer { const struct WellControls * ctrls1 = ctrls[1]; BOOST_CHECK_EQUAL( 3 , well_controls_get_num(ctrls1)); // The number of controls for the producer - now 3. BOOST_CHECK_EQUAL( SURFACE_RATE , well_controls_iget_type(ctrls1 , 0) ); BOOST_CHECK_EQUAL( RESERVOIR_RATE , well_controls_iget_type(ctrls1 , 1) ); BOOST_CHECK_EQUAL( BHP , well_controls_iget_type(ctrls1 , 2) ); // The different targets BOOST_CHECK_CLOSE( -999.0 / 86400 , well_controls_iget_target(ctrls1 , 0), 0.001); BOOST_CHECK_CLOSE( -123.0 / 86400 , well_controls_iget_target(ctrls1 , 1), 0.001); BOOST_CHECK_CLOSE( 100 * 100000 , well_controls_iget_target(ctrls1 , 2), 0.001); // Which control is active BOOST_CHECK_EQUAL( 1 , well_controls_get_current(ctrls1) ); { const double * distr = well_controls_iget_distr( ctrls1 , 1 ); BOOST_CHECK_EQUAL( 1 , distr[0] ); // Water BOOST_CHECK_EQUAL( 1 , distr[1] ); // Oil BOOST_CHECK_EQUAL( 1 , distr[2] ); // Gas } } }
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign5, mp_int_type, mp_int_types) { mp_int_type x("0xabcedf03030303"); x = "-012345676543210000001"; BOOST_CHECK_EQUAL(x, "-012345676543210000001"); }
void check_controls_epoch0( struct WellControls ** ctrls) { // The injector { const struct WellControls * ctrls0 = ctrls[0]; BOOST_CHECK_EQUAL( 3 , well_controls_get_num(ctrls0)); // The number of controls for the injector == 3?? BOOST_CHECK_EQUAL( SURFACE_RATE , well_controls_iget_type(ctrls0 , 0) ); BOOST_CHECK_EQUAL( RESERVOIR_RATE , well_controls_iget_type(ctrls0 , 1) ); BOOST_CHECK_EQUAL( BHP , well_controls_iget_type(ctrls0 , 2) ); // The different targets BOOST_CHECK_EQUAL( 100.0 / 86400 , well_controls_iget_target(ctrls0,0)); BOOST_CHECK_EQUAL( 200.0 / 86400 , well_controls_iget_target(ctrls0,1)); BOOST_CHECK_EQUAL( 400 * 100000 , well_controls_iget_target(ctrls0,2)); // Which control is active BOOST_CHECK_EQUAL( 0 , well_controls_get_current(ctrls0) ); // The phase distribution in the active target { const double * distr = well_controls_iget_distr( ctrls0 , 0 ); BOOST_CHECK_EQUAL( 0 , distr[0] ); // Water BOOST_CHECK_EQUAL( 0 , distr[1] ); // Oil BOOST_CHECK_EQUAL( 1 , distr[2] ); // Gas } } // The producer { const struct WellControls * ctrls1 = ctrls[1]; BOOST_CHECK_EQUAL( 2 , well_controls_get_num( ctrls1 )); // The number of controls for the producer == 2?? BOOST_CHECK_EQUAL( SURFACE_RATE , well_controls_iget_type(ctrls1 , 0) ); BOOST_CHECK_EQUAL( BHP , well_controls_iget_type(ctrls1 , 1) ); // The different targets BOOST_CHECK_EQUAL( -20000.0 / 86400 , well_controls_iget_target(ctrls1,0)); BOOST_CHECK_EQUAL( 1000 * 100000 , well_controls_iget_target(ctrls1,1)); // Which control is active BOOST_CHECK_EQUAL( 0 , well_controls_get_current(ctrls1)); // The phase distribution in the active target { const double * distr = well_controls_iget_distr( ctrls1 , 0 ); BOOST_CHECK_EQUAL( 0 , distr[0] ); // Water BOOST_CHECK_EQUAL( 1 , distr[1] ); // Oil BOOST_CHECK_EQUAL( 0 , distr[2] ); // Gas } } }
BOOST_AUTO_TEST_CASE_TEMPLATE(assign1, mp_int_type, mp_int_types) { mp_int_type x; x.assign("123456789876543210000001", std::ios::dec); BOOST_CHECK_EQUAL(x, "123456789876543210000001"); }
void compare(TValueType const & t1, TValueType const & t2) { BOOST_CHECK_EQUAL(t1, t2); }
BOOST_AUTO_TEST_CASE_TEMPLATE(assign2, mp_int_type, mp_int_types) { mp_int_type x; x.assign("abcdefabcdef1234567890", std::ios::hex); BOOST_CHECK_EQUAL(x, "0xabcdefabcdef1234567890"); }
static void test_capture() { bp::stream_behavior sb = bp::capture_stream(); BOOST_CHECK_EQUAL(sb.get_type(), bp::stream_behavior::capture); }
static void test_quoting() { BOOST_CHECK_EQUAL(get_argument("foo"), ">>>foo<<<"); BOOST_CHECK_EQUAL(get_argument("foo "), ">>>foo <<<"); BOOST_CHECK_EQUAL(get_argument(" foo"), ">>> foo<<<"); BOOST_CHECK_EQUAL(get_argument("foo bar"), ">>>foo bar<<<"); BOOST_CHECK_EQUAL(get_argument("foo\"bar"), ">>>foo\"bar<<<"); BOOST_CHECK_EQUAL(get_argument("foo\"bar\""), ">>>foo\"bar\"<<<"); BOOST_CHECK_EQUAL(get_argument("\"foo\"bar"), ">>>\"foo\"bar<<<"); BOOST_CHECK_EQUAL(get_argument("\"foo bar\""), ">>>\"foo bar\"<<<"); BOOST_CHECK_EQUAL(get_argument("*"), ">>>*<<<"); BOOST_CHECK_EQUAL(get_argument("?*"), ">>>?*<<<"); BOOST_CHECK_EQUAL(get_argument("[a-z]*"), ">>>[a-z]*<<<"); }