Esempio n. 1
0
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>());
   }
}
Esempio n. 3
0
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]);
        }
    }
}
Esempio n. 4
0
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());
}
Esempio n. 5
0
 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");
}
Esempio n. 8
0
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.);
}
Esempio n. 9
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);
}
Esempio n. 10
0
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));
}
Esempio n. 11
0
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));
}
Esempio n. 12
0
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);
}
Esempio n. 13
0
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());
}
Esempio n. 14
0
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);
}
Esempio n. 15
0
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");
}
Esempio n. 16
0
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);
}
Esempio n. 17
0
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");
}
Esempio n. 18
0
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign2, mp_int_type, mp_int_types)
{
  mp_int_type x;
  x = "0xabcdef123456789";
  BOOST_CHECK_EQUAL(x, "0xabcdef123456789");
}
Esempio n. 19
0
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");
}
Esempio n. 20
0
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign3, mp_int_type, mp_int_types)
{
  mp_int_type x;
  x = "012345676543210000001";
  BOOST_CHECK_EQUAL(x, "012345676543210000001");
}
Esempio n. 21
0
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign1, mp_int_type, mp_int_types)
{
  mp_int_type x;
  x = "269513460";
  BOOST_CHECK_EQUAL(x, "269513460");
}
Esempio n. 22
0
BOOST_AUTO_TEST_CASE_TEMPLATE(op_assign4, mp_int_type, mp_int_types)
{
  mp_int_type x;
  x = "0";
  BOOST_CHECK_EQUAL(!x, true);
}
Esempio n. 23
0
        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
                }
            }
        }
Esempio n. 24
0
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");
}
Esempio n. 25
0
        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
                }
            }
        }
Esempio n. 26
0
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");
}
Esempio n. 27
0
void compare(TValueType const & t1, TValueType const & t2)
{
    BOOST_CHECK_EQUAL(t1, t2);
}
Esempio n. 28
0
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); 
 } 
Esempio n. 30
0
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]*<<<"); 
}