예제 #1
0
			void signal_vector_unit_tests()
			{
				class signal_vector_test_class : public signal_vector< double >
				{
				};

				signal_vector_test_class svtc;
				signal_vector_test_class svtc2( svtc );

				common::bar_type b1;
				BOOST_CHECK_NO_THROW( svtc.insert( &b1, new double( 1.5 ) ) );
				common::bar_type b2;
				BOOST_CHECK_NO_THROW( svtc.insert( &b2, new double( 1.3 ) ) );
				{
					const double* throw_double( new double( 1.3 ) );
					BOOST_CHECK_THROW( svtc.insert( &b2, throw_double ), std::exception );
				}

				const double* e = svtc.at( &b2 );
				BOOST_CHECK_EQUAL( *e, 1.3 );
				BOOST_CHECK_EQUAL( *svtc2.at( &b1 ), 1.5 );
				BOOST_CHECK_EQUAL( *svtc.at( &b1 ), 1.5 );
				BOOST_CHECK_NO_THROW( svtc2.clear() );
				BOOST_CHECK_NO_THROW( svtc.at( &b1 ) );
				BOOST_CHECK_EQUAL( svtc.at( &b1 ) == NULL, true );

				BOOST_CHECK_NO_THROW( svtc.subscription_check( typeid( double ) ) );
				BOOST_CHECK_THROW( svtc2.subscription_check( typeid( float ) ), std::exception );
			}
예제 #2
0
    //
    // Constructor test cases
    //
    void SecurityFileTestCases::TestCase_Constructor()
    {
        TIdent configuredCustomers(5000);
        TIdent activeCustomers(5000);

        TPCE::TextFileSplitter* splitter = new TPCE::TextFileSplitter("../../../flat_in/Security.txt");
        TPCE::SecurityDataFile_t* df = new TPCE::SecurityDataFile_t(*splitter);
        TPCE::CSecurityFile* file;

        // Construct the object.
        BOOST_CHECK_NO_THROW( file = new TPCE::CSecurityFile(*df, configuredCustomers, activeCustomers, TPCE::iBaseCompanyCount) );
        CleanUp(&file);
        CleanUp(&df);
        CleanUp(&splitter);

        // Change the scale.
        configuredCustomers = 10000;
        activeCustomers = 10000;

        splitter = new TPCE::TextFileSplitter("../../../flat_in/Security.txt");
        df = new TPCE::SecurityDataFile_t(*splitter);

        // Construct the object.
        BOOST_CHECK_NO_THROW( file = new TPCE::CSecurityFile(*df, configuredCustomers, activeCustomers, TPCE::iBaseCompanyCount) );

        CleanUp(&file);
        CleanUp(&df);
        CleanUp(&splitter);
    }
			/// \brief TODOCUMENT
			void operator()() {
				constexpr std_classn_rate_stat to_test = get<0>( get<I>( properties_of_classn_rate_stat::numerator_and_denominator_of_stat ) );
				BOOST_CHECK_NO_THROW( classn_rate_stat<to_test>() );
				classn_rate_stat<to_test> stat;
				BOOST_CHECK_NO_THROW( stat.get_name() );
				BOOST_CHECK_GT( stat.get_name().length(), 0 );
			}
void queue_logger_constructor_tests()
{
    std::stringstream str;
    queue_logger<>::tasker task_processor( 4 );
    BOOST_CHECK_NO_THROW( queue_logger<> first_logger( str, task_processor ) );
    BOOST_CHECK_NO_THROW( queue_logger<> second_logger( str, task_processor ) );
}
예제 #5
0
	void test_image_formats() {
		BOOST_CHECK_NO_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.png", ssm));
		BOOST_CHECK_NO_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.svg", ssm));
		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.jpg", ssm), excp::UnknownImageFormatException);
		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.jpeg", ssm), excp::UnknownImageFormatException);
		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.gif", ssm), excp::UnknownImageFormatException);
		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.svgz", ssm), excp::UnknownImageFormatException);
	}
			void logger_constructor_tests()
			{
				std::stringstream str;
				BOOST_CHECK_NO_THROW( (logger< false >( str )) );
				BOOST_CHECK_NO_THROW( (logger< true >( str )) );
				BOOST_CHECK_NO_THROW( (logger< true, false >( str )) );
				BOOST_CHECK_NO_THROW( (logger< true, false, false >( str )) );
				BOOST_CHECK_NO_THROW( (logger< true, true, false >( str )) );
			}
예제 #7
0
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_auto_ptr_value, mock_error_fixture )
{
    {
        mock::detail::function< std::auto_ptr< int >() > f;
        std::auto_ptr< int > ptr( new int( 3 ) );
        f.expect().returns( boost::ref( ptr ) );
        BOOST_CHECK_EQUAL( 3, *ptr );
        BOOST_CHECK_EQUAL( 3, *f() );
        BOOST_CHECK( ! ptr.get() );
        BOOST_CHECK( ! f().get() );
        CHECK_CALLS( 2 );
    }
    {
        mock::detail::function< std::auto_ptr< int >() > f;
        std::auto_ptr< int > ptr( new int( 3 ) );
        f.expect().returns( ptr );
        BOOST_CHECK( ! ptr.get() );
        BOOST_CHECK_EQUAL( 3, *f() );
        BOOST_CHECK( ! f().get() );
        CHECK_CALLS( 2 );
    }
    {
        mock::detail::function< std::auto_ptr< int >() > f;
        f.expect().returns( new int( 3 ) );
        BOOST_CHECK_EQUAL( 3, *f() );
        BOOST_CHECK( ! f().get() );
        CHECK_CALLS( 2 );
    }
    {
        mock::detail::function< std::auto_ptr< int >() > f;
        f.expect().returns( std::auto_ptr< int >( new int( 3 ) ) );
        BOOST_CHECK_EQUAL( 3, *f() );
        BOOST_CHECK( ! f().get() );
        CHECK_CALLS( 2 );
    }
    {
        mock::detail::function< std::auto_ptr< base >() > f;
        f.expect().returns( new derived );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< std::auto_ptr< base >() > f;
        f.expect().returns( std::auto_ptr< base >( new derived ) );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< std::auto_ptr< base >() > f;
        f.expect().returns( std::auto_ptr< derived >( new derived ) );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
}
예제 #8
0
	void test_delete_tiles() {
		char* argv[] = {(char*)"ala.carte", (char*)"ala.carte"};
		ConfigMockup* mock = new ConfigMockup();
		shared_ptr<Configuration> config = mock->Config(argv, 2);
		shared_ptr<Cache> cache = shared_ptr<Cache>(new Cache(config));
		// Delete not existing cache.
		BOOST_CHECK_NO_THROW(cache->deleteTiles("nothing"));
		shared_ptr<TileIdentifier> ti = boost::make_shared<TileIdentifier>(0, 0, 0, "default", TileIdentifier::Format::PNG);
		BOOST_CHECK_NO_THROW(cache->getTile(ti));
		// Delete existing cache.
		BOOST_CHECK_NO_THROW(cache->deleteTiles("/default"));
	}
		static void Copy( std::random_device & generator )
		{
			String connectionString;
			DatabaseConnectionSPtr connection = std::make_shared< CDatabaseTestConnection >( TEST_GOOD_SERVER, TEST_GOOD_USER, TEST_GOOD_PASSWORD, connectionString );
			connection->SelectDatabase( TEST_GOOD_DATABASE );
			CDatabaseValue< ValueType > valueA( connection );
			BOOST_CHECK_NO_THROW( valueA.SetValue( DatabaseUtils::Helpers< ValueType >::GetRandomValue( generator ) ) );
			CDatabaseValue< ValueType > valueB( connection );
			BOOST_CHECK_NO_THROW( valueB.SetValue( DatabaseUtils::Helpers< ValueType >::GetRandomValue( generator ) ) );
			BOOST_CHECK_NO_THROW( valueA.SetValue( valueB ) );
			BOOST_CHECK_EQUAL( valueA.GetValue(), valueB.GetValue() );
		}
		void async_tests_work()
		{			
			// this test dependent on tcp port availability, please be sure that 50000 port is free
			static const unsigned short port = 50000;		
			detail::tcp_client_manager_test tcp_manager; 
			{
				detail::async_tcp_helper helper( port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				tcp_client client( tcp_manager, "127.0.0.1", port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				BOOST_CHECK_NO_THROW( helper.check_connection() );
				BOOST_CHECK_NO_THROW( helper.close_socket() );
			}
			{
				detail::async_tcp_helper helper( port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				tcp_client client( tcp_manager, "127.0.0.1", port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				BOOST_CHECK_NO_THROW( helper.send() );
				BOOST_CHECK_NO_THROW( helper.check_connection() );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				BOOST_CHECK_NO_THROW( helper.close_socket() );
			}
			{
				detail::async_tcp_helper helper( port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				tcp_client client( tcp_manager, "127.0.0.1", port );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				BOOST_CHECK_NO_THROW( client.write( "test", 4 ) );
				BOOST_CHECK_NO_THROW( helper.check_connection() );
				boost::this_thread::sleep( boost::posix_time::milliseconds( 10 ) );
				BOOST_CHECK_NO_THROW( helper.close_socket() );
			}
		}
예제 #11
0
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);
}
예제 #12
0
    //
    // Constructor test cases
    //
    void StringSplitterTestCases::TestCase_Constructor_Default()
    {
        // Construct the object.
        BOOST_CHECK_NO_THROW( splitter1 = new TPCE::StringSplitter(defaultTestString) );
        CleanUp(&splitter1);

        // Construct the object.
        BOOST_CHECK_NO_THROW( splitter1 = new TPCE::StringSplitter(mixedTestString, '_') );
        CleanUp(&splitter1);

        // Construct the object.
        BOOST_CHECK_NO_THROW( splitter1 = new TPCE::StringSplitter(customTestString, '_', '-') );
        CleanUp(&splitter1);
    }
예제 #13
0
BOOST_AUTO_TEST_CASE_TEMPLATE(InstanceName, T, Tests)
{
  BOOST_REQUIRE(T::Strategy::getStrategyName().at(-1).isVersion());
  uint64_t maxVersion = T::Strategy::getStrategyName().at(-1).toVersion();
  BOOST_REQUIRE_LE(T::getMinVersion(), maxVersion);

  Forwarder forwarder;
  for (uint64_t version = T::getMinVersion(); version <= maxVersion; ++version) {
    Name versionedName = T::getVersionedStrategyName(version);
    unique_ptr<typename T::Strategy> instance;
    BOOST_CHECK_NO_THROW(instance = make_unique<typename T::Strategy>(forwarder, versionedName));
    BOOST_CHECK_EQUAL(instance->getInstanceName(), versionedName);

    if (!T::canAcceptParameters()) {
      Name nameWithParameters = Name(versionedName).append("param");
      BOOST_CHECK_THROW(typename T::Strategy(forwarder, nameWithParameters), std::invalid_argument);
    }
  }

  if (T::getMinVersion() > 0) {
    Name version0Name = T::getVersionedStrategyName(0);
    BOOST_CHECK_THROW(typename T::Strategy(forwarder, version0Name), std::invalid_argument);
    Name earlyVersionName = T::getVersionedStrategyName(T::getMinVersion() - 1);
    BOOST_CHECK_THROW(typename T::Strategy(forwarder, earlyVersionName), std::invalid_argument);
  }

  if (maxVersion < std::numeric_limits<uint64_t>::max()) {
    Name versionMaxName = T::getVersionedStrategyName(std::numeric_limits<uint64_t>::max());
    BOOST_CHECK_THROW(typename T::Strategy(forwarder, versionMaxName), std::invalid_argument);
    Name lateVersionName = T::getVersionedStrategyName(maxVersion + 1);
    BOOST_CHECK_THROW(typename T::Strategy(forwarder, lateVersionName), std::invalid_argument);
  }
}
  void
  decodeFibEntryBlock(const Data& data)
  {
    Block payload = data.getContent();

    m_buffer.appendByteArray(payload.value(), payload.value_size());

    BOOST_CHECK_NO_THROW(data.getName()[-1].toSegment());
    if (data.getFinalBlockId() != data.getName()[-1])
      {
        return;
      }

    // wrap the FIB Entry blocks in a single Content TLV for easy parsing
    m_buffer.prependVarNumber(m_buffer.size());
    m_buffer.prependVarNumber(ndn::Tlv::Content);

    ndn::Block parser(m_buffer.buf(), m_buffer.size());
    parser.parse();

    BOOST_REQUIRE_EQUAL(parser.elements_size(), m_referenceEntries.size());

    for (Block::element_const_iterator i = parser.elements_begin();
         i != parser.elements_end();
         ++i)
      {
        if (i->type() != ndn::tlv::nfd::FibEntry)
          {
            BOOST_FAIL("expected fib entry, got type #" << i->type());
          }

        validateFibEntry(*i);
      }
    m_finished = true;
  }
예제 #15
0
	void test_correct() {
		shared_ptr<TileIdentifier> ti;
		BOOST_CHECK_NO_THROW(ti = TileIdentifier::Create((const string&)"/folder/stylesheet/2/1/0.svg", ssm));
		BOOST_CHECK_EQUAL(ti->getX(), 1);
		BOOST_CHECK_EQUAL(ti->getY(), 0);
		BOOST_CHECK_EQUAL(ti->getZoom(), 2);
		BOOST_CHECK_EQUAL(ti->getImageFormat(), TileIdentifier::Format::SVG);
		BOOST_CHECK_EQUAL(ti->getStylesheetPath(), "folder/stylesheet");
		BOOST_CHECK_NO_THROW(ti = TileIdentifier::CreateEmptyTID(ti->getStylesheetPath(), ti->getImageFormat()));
		BOOST_CHECK_EQUAL(ti->getX(), -2);
		BOOST_CHECK_EQUAL(ti->getY(), -2);
		BOOST_CHECK_EQUAL(ti->getZoom(), -2);
		BOOST_CHECK_EQUAL(ti->getImageFormat(), TileIdentifier::Format::SVG);
		BOOST_CHECK_EQUAL(ti->getStylesheetPath(), "folder/stylesheet");
		BOOST_CHECK(ti->isNoneDataIdentifier());
	}
예제 #16
0
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_rvalue, mock_error_fixture )
{
    mock::detail::function< int() > f;
    f.expect().moves( 3 );
    BOOST_CHECK_NO_THROW( f() );
    CHECK_CALLS( 1 );
}
예제 #17
0
	void check_requestTile(std::string url, HttpRequest::Reply::StatusType responseStatus = HttpRequest::Reply::ok)
    {
		int result = -2;
		BOOST_CHECK_NO_THROW((result = sendRequest(url)));
		BOOST_CHECK_EQUAL(result, (int)responseStatus);
		
    }
예제 #18
0
					static void simple_work_tests()
					{	
						const int lowest=-10, highest=10;
						const int range = ( highest-lowest ) + 1;
						int cents = lowest + int( range * rand() / ( RAND_MAX + 1.0 ) );

						{
							typedef double number_type;
							const size_t window = 5;
							moving_median<number_type> median( window );
							BOOST_CHECK_THROW( median.get_median(), std::logic_error );

							const number_type value = 16;
							
							for ( int i = 0; i < 100; ++i)
							{		
								cents = lowest + int( range * rand() / ( RAND_MAX + 1.0 ) );
									
								const number_type value_to_add = ( i % 3 == 0 ) ? value + (double)cents / 100 : value;								
								median.add_element( value_to_add );
									
								if ( i < window - 1 )
								{
									BOOST_CHECK_EQUAL( median.get_median(), value_to_add );
								} else
								{
									BOOST_CHECK_EQUAL( median.get_median(), value );
								}
							}
						}
						{
							typedef double number_type;

							const size_t window = 19;
							moving_median< number_type> median( window );	
							BOOST_CHECK_THROW( median.get_median(), std::logic_error );

							const number_type value = 16;			
							const double cents = 0.01;
							for ( int i = 0; i < 100; ++i)
							{							
								const number_type value_to_add = ( i % 2 == 0 ) ? value + (double)cents / 100 : value;								
								median.add_element( value_to_add );								
								if ( i < window - 1 )
								{
									BOOST_CHECK_EQUAL( median.get_median(), value_to_add );
								}
								else
								{
									BOOST_CHECK_EQUAL( median.get_median(), value_to_add );
								}
							}
						}
						{ /// simple adding the same value						
							moving_median< double > median( 5 );
							for ( size_t i = 0 ; i < 1000 ; ++i )
								BOOST_CHECK_NO_THROW( median.add_element( 0.9999999990621 ) );
						}
					}
 static void All()
 {
     static const String FieldName = STR( "coin" );
     DatabaseValuedObjectInfosSPtr infos;
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName ) );
     BOOST_CHECK( infos );
     BOOST_CHECK( infos->GetName() == FieldName );
     BOOST_CHECK( infos->GetType() == EFieldType_NULL );
     BOOST_CHECK_NO_THROW( infos->SetType( FieldType ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, 0 ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, std::make_pair( 0, 0 ) ) );
     BOOST_CHECK( infos->GetType() == FieldType );
 }
예제 #20
0
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_moves_the_set_unique_ptr_lvalue, mock_error_fixture )
{
    mock::detail::function< std::unique_ptr< int >() > f;
    std::unique_ptr< int > p( new int );
    f.expect().moves( std::move( p ) );
    BOOST_CHECK_NO_THROW( f() );
    CHECK_CALLS( 1 );
}
예제 #21
0
void task4_5::tests_::solution_simple_tests()
{
	task4_5::data_type data;

	BOOST_CHECK_NO_THROW( solution s( data ) );
	solution s( data );
	BOOST_CHECK_EQUAL( s.get_min(), 0 );
	BOOST_CHECK_EQUAL( s.get_max(), 0 );
}
예제 #22
0
BOOST_FIXTURE_TEST_CASE(EcdsaSigningByIdentityNoCert, IdentityManagementFixture)
{
  Data data("/test/data");

  Name nonExistingIdentity = Name("/non-existing/identity").appendVersion();

  BOOST_CHECK_NO_THROW(m_keyChain.sign(data, signingByIdentity(nonExistingIdentity)));
  BOOST_CHECK_EQUAL(data.getSignature().getType(),
                    KeyChain::getSignatureType(KeyChain::DEFAULT_KEY_PARAMS.getKeyType(),
                                               DigestAlgorithm::SHA256));
  BOOST_CHECK(nonExistingIdentity.isPrefixOf(data.getSignature().getKeyLocator().getName()));

  Name ecdsaIdentity = Name("/ndn/test/ecdsa").appendVersion();
  Name ecdsaKeyName = m_keyChain.generateEcdsaKeyPairAsDefault(ecdsaIdentity, false, 256);
  BOOST_CHECK_NO_THROW(m_keyChain.sign(data, signingByIdentity(ecdsaIdentity)));
  BOOST_CHECK_EQUAL(data.getSignature().getType(),
                    KeyChain::getSignatureType(EcdsaKeyParams().getKeyType(), DigestAlgorithm::SHA256));
  BOOST_CHECK(ecdsaIdentity.isPrefixOf(data.getSignature().getKeyLocator().getName()));
}
		static void QueryValue( std::random_device & generator )
		{
			String connectionString;
			DatabaseConnectionSPtr connection = std::make_shared< CDatabaseTestConnection >( TEST_GOOD_SERVER, TEST_GOOD_USER, TEST_GOOD_PASSWORD, connectionString );
			connection->SelectDatabase( TEST_GOOD_DATABASE );
			CDatabaseValue< ValueType > value( connection );
			auto val = DatabaseUtils::Helpers< ValueType >::GetRandomValue( generator );
			BOOST_CHECK_NO_THROW( value.SetValue( val ) );
			ValueChecker< ValueType >::QueryValueCompare( connection, value, val );
		}
예제 #24
0
 void
 checkValidity(std::string parameters, bool isCorrect)
 {
   Name strategyName(Name(AsfStrategy::getStrategyName()).append(parameters));
   if (isCorrect) {
     BOOST_CHECK_NO_THROW(make_unique<AsfStrategy>(forwarder, strategyName));
   }
   else {
     BOOST_CHECK_THROW(make_unique<AsfStrategy>(forwarder, strategyName), std::invalid_argument);
   }
 }
 static void All()
 {
     static const String FieldName = STR( "coin" );
     static const std::pair< uint32_t, uint32_t > FieldPrecision = std::make_pair( 10, 5 );
     DatabaseValuedObjectInfosSPtr infos;
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName ) );
     BOOST_CHECK( infos );
     BOOST_CHECK( infos->GetName() == FieldName );
     BOOST_CHECK( infos->GetType() == EFieldType_NULL );
     BOOST_CHECK_THROW( infos->SetType( FieldType ), CDatabaseException );
     BOOST_CHECK_THROW( infos->SetType( FieldType, FieldPrecision.first ), CDatabaseException );
     BOOST_CHECK_NO_THROW( infos->SetType( FieldType, FieldPrecision ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK( infos->GetPrecision() == FieldPrecision );
     BOOST_CHECK_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType ), CDatabaseException );
     BOOST_CHECK_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, FieldPrecision.first ), CDatabaseException );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, FieldPrecision ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK( infos->GetPrecision() == FieldPrecision );
 }
			void multikey_tree_with_map_comparator_tests()
			{
				static const size_t test_size = 1000;
				{
					time_tracker tt;
					multikey_tree< size_t > mkt;
					for ( size_t i = 0 ; i < test_size ; ++i )
						BOOST_CHECK_NO_THROW( (*mkt.get_for_edit( get_random_stock_name( 4 ) )) = i );
					for ( size_t i = 0 ; i < test_size ; ++i )
						BOOST_CHECK_NO_THROW( (*mkt.get_for_edit( get_random_stock_name( 4 ) )) = i );
				}
				{
					time_tracker tt;
					std::map< std::string, size_t > mt;
					for ( size_t i = 0 ; i < test_size ; ++i )
						mt[ get_random_stock_name( 4 ) ] = i;
					for ( size_t i = 0 ; i < test_size ; ++i )
						mt[ get_random_stock_name( 4 ) ] = i;
				}
			}
예제 #27
0
BOOST_AUTO_TEST_CASE_TEMPLATE(http_client_get_test, client, client_types) {
    typename client::request request("http://www.boost.org");
    client client_;
    typename client::response response;
    BOOST_CHECK_NO_THROW ( response = client_.get(request) );
    typename net::headers_range<typename client::response>::type range = headers(response)["Content-Type"];
    BOOST_CHECK ( !boost::empty(range) );
    BOOST_CHECK ( body(response).size() != 0 );
    BOOST_CHECK_EQUAL ( response.version().substr(0,7), std::string("HTTP/1.") );
    BOOST_CHECK_EQUAL ( response.status(), 200u );
    BOOST_CHECK_EQUAL ( response.status_message(), std::string("OK") );
}
예제 #28
0
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_the_set_shared_ptr_value, mock_error_fixture )
{
    {
        mock::detail::function< boost::shared_ptr< base >() > f;
        f.expect().returns( new derived );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< const boost::shared_ptr< base >&() > f;
        f.expect().returns( new derived );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< boost::shared_ptr< base >&() > f;
        f.expect().returns( new derived );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
}
 static void All()
 {
     static const String FieldName = STR( "coin" );
     static const uint32_t FieldLimits = 10;
     DatabaseValuedObjectInfosSPtr infos;
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName ) );
     BOOST_CHECK( infos );
     BOOST_CHECK( infos->GetName() == FieldName );
     BOOST_CHECK( infos->GetType() == EFieldType_NULL );
     BOOST_CHECK_THROW( infos->SetType( FieldType ), CDatabaseException );
     BOOST_CHECK_NO_THROW( infos->SetType( FieldType, FieldLimits ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK( infos->GetLimits() == FieldLimits );
     BOOST_CHECK_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType ), CDatabaseException );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, FieldLimits ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK( infos->GetLimits() == FieldLimits );
     BOOST_CHECK_NO_THROW( infos = std::make_shared< CDatabaseValuedObjectInfos >( FieldName, FieldType, std::make_pair( FieldLimits, 0 ) ) );
     BOOST_CHECK( infos->GetType() == FieldType );
     BOOST_CHECK( infos->GetLimits() == FieldLimits );
 }
예제 #30
0
BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_returns_by_reference, mock_error_fixture )
{
    {
        mock::detail::function< base&() > f;
        derived b;
        f.expect().returns( boost::ref( b ) );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< base&() > f;
        derived b;
        f.expect().returns( b );
        BOOST_CHECK_NO_THROW( f() );
        CHECK_CALLS( 1 );
    }
    {
        mock::detail::function< undefined&() > f;
        f.expect().returns( boost::ref( get_undefined() ) );
        f.reset();
    }
}