自学教程：C++ BOOST_CHECK_THROW函数代码示例

void try_lock_twice(){    boost::fibers::mutex mtx;    boost::unique_lock< boost::fibers::mutex > lk( mtx);    BOOST_CHECK_THROW( lk.try_lock(), boost::lock_error);}

inline void testReadUntilFiltered(const char* format){    TemporaryData data{format};    brion::SpikeReport reportWrite(brion::URI(data.tmpFileName),                                   brion::MODE_WRITE);    reportWrite.write(data.spikes);    reportWrite.close();    brion::SpikeReport reportRead(brion::URI(data.tmpFileName),                                  brion::GIDSet{22, 25});    auto spikes = reportRead.readUntil(0.4).get();    BOOST_CHECK_EQUAL(spikes.size(), 1);    BOOST_CHECK(reportRead.getCurrentTime() >= 0.4f);    BOOST_CHECK(spikes.rbegin()->first < 0.4);    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ok);    spikes = reportRead.readUntil(brion::UNDEFINED_TIMESTAMP).get();    BOOST_CHECK_EQUAL(spikes.size(), 1);    BOOST_CHECK_EQUAL(reportRead.getCurrentTime(), brion::UNDEFINED_TIMESTAMP);    BOOST_CHECK_EQUAL(reportRead.getState(), brion::SpikeReport::State::ended);    BOOST_CHECK_THROW(reportRead.read(reportRead.getCurrentTime()),                      std::logic_error);}

BOOST_FIXTURE_TEST_CASE( test_suite_loop5, _2suites_4_cases ){    tc1->depends_on( s1 );    master->p_default_status.value = ut::test_unit::RS_ENABLED;    BOOST_CHECK_THROW( ut::framework::finalize_setup_phase( master->p_id ),                       ut::framework::setup_error );}

inline void testInvalidWrite(const char* format){    TemporaryData data{format};    brion::SpikeReport reportWrite(brion::URI(data.tmpFileName),                                   brion::MODE_WRITE);    reportWrite.write(data.spikes);    BOOST_CHECK_THROW(reportWrite.write({{0.0, 0}}), std::logic_error);    BOOST_CHECK_THROW(reportWrite.write(                          {{10.0, 0}, {10.0, 1}, {11.0, 0}, {0.5, 1}}),                      std::logic_error);    brion::SpikeReport reportRead{brion::URI(data.tmpFileName),                                  brion::MODE_READ};    BOOST_CHECK_THROW(reportRead.write({{100.0, 0}}), std::runtime_error);}

    void operator()() const    {        Mutex m;        Lock lock(m);        lock.unlock();        BOOST_CHECK_THROW( lock.unlock(), boost::lock_error );    }

void test_unlock_twice(){	boost::fibers::spin::mutex mtx;	boost::unique_lock< boost::fibers::spin::mutex > lk( mtx);	lk.unlock();	BOOST_CHECK_THROW( lk.unlock(), boost::lock_error);}

BOOST_AUTO_TEST_CASE_TEMPLATE(members, T, float_types) {	vmath::core::Matrix<T, 3> M;	M[0] = vmath::core::Vector<T, 3>(static_cast<T>(1.0), static_cast<T>(2.0), static_cast<T>(3.0));	M[1] = vmath::core::Vector<T, 3>(static_cast<T>(4.0), static_cast<T>(5.0), static_cast<T>(6.0));	M[2] = vmath::core::Vector<T, 3>(static_cast<T>(7.0), static_cast<T>(8.0), static_cast<T>(9.0));	BOOST_CHECK_CLOSE(M[0][0], static_cast<T>(1.0), 1e-4f);	BOOST_CHECK_CLOSE(M[0][1], static_cast<T>(2.0), 1e-4f);	BOOST_CHECK_CLOSE(M[0][2], static_cast<T>(3.0), 1e-4f);	BOOST_CHECK_CLOSE(M[1][0], static_cast<T>(4.0), 1e-4f);	BOOST_CHECK_CLOSE(M[1][1], static_cast<T>(5.0), 1e-4f);	BOOST_CHECK_CLOSE(M[1][2], static_cast<T>(6.0), 1e-4f);	BOOST_CHECK_CLOSE(M[2][0], static_cast<T>(7.0), 1e-4f);	BOOST_CHECK_CLOSE(M[2][1], static_cast<T>(8.0), 1e-4f);	BOOST_CHECK_CLOSE(M[2][2], static_cast<T>(9.0), 1e-4f);	// invalid index	BOOST_CHECK_THROW(M[3], std::out_of_range);	BOOST_CHECK_THROW((M[3] = vmath::core::Vector<T, 3>()), std::out_of_range);}

void const_test_f( json::value const & value ){   BOOST_CHECK(value.has_key("cafe"));   BOOST_CHECK_THROW(value["sam"], std::out_of_range);   BOOST_CHECK_EQUAL(value["cafe"], "open");   BOOST_CHECK_EQUAL(value["bar"][2], 1234.5);}

 void C2STestSocketListener::runTest() {   C2STestSocketListener testSocketListener;   BOOST_CHECK_THROW( testSocketListener.sendTestMessageThroughSocket() , C2SSocketException );   testSocketListener.startSocketListener();   testSocketListener.sendTestMessageThroughSocket();   testSocketListener.sendTestMessageThroughSocket();   testSocketListener.shutdownSocketListener(); }

WESNOTH_PARAMETERIZED_TEST_CASE( test_multi_sendfile, sendfile_param, sendfile_sizes, size ){	auto_resetter<std::string> path("", game_config::path);	network::set_raw_data_only();	std::string file = create_random_sendfile(size.size_);	network_worker_pool::set_use_system_sendfile(size.system_);	network::connection cl_client1, se_client1;	network::connection cl_client2, se_client2;	network::connection cl_client3, se_client3;	BOOST_CHECK_MESSAGE((cl_client1 = network::connect(LOCALHOST, TEST_PORT)) > 0, "Can't connect to server!");	BOOST_CHECK_MESSAGE((se_client1 = network::accept_connection()) > 0, "Coulnd't accept new connection");	BOOST_CHECK_MESSAGE((cl_client2 = network::connect(LOCALHOST, TEST_PORT)) > 0, "Can't connect to server!");	BOOST_CHECK_MESSAGE((se_client2 = network::accept_connection()) > 0, "Coulnd't accept new connection");	BOOST_CHECK_MESSAGE((cl_client3 = network::connect(LOCALHOST, TEST_PORT)) > 0, "Can't connect to server!");	BOOST_CHECK_MESSAGE((se_client3 = network::accept_connection()) > 0, "Coulnd't accept new connection");	network::send_file(file, cl_client1);	network::send_file(file, cl_client2);	network::send_file(file, cl_client3);	std::vector<char> data;	BOOST_CHECK_PREDICATE(test_utils::one_of<network::connection> , (receive(data,500))(3)(se_client1)(se_client2)(se_client3));	BOOST_CHECK_EQUAL(data.size(), static_cast<size_t>(file_size(file)));	BOOST_CHECK_PREDICATE(test_utils::one_of<network::connection> , (receive(data,500))(3)(se_client1)(se_client2)(se_client3));	BOOST_CHECK_EQUAL(data.size(), static_cast<size_t>(file_size(file)));	BOOST_CHECK_PREDICATE(test_utils::one_of<network::connection> , (receive(data,500))(3)(se_client1)(se_client2)(se_client3));	BOOST_CHECK_EQUAL(data.size(), static_cast<size_t>(file_size(file)));	network::disconnect(cl_client1);	network::disconnect(cl_client2);	network::disconnect(cl_client3);	BOOST_CHECK_THROW(receive(data),network::error);	BOOST_CHECK_THROW(receive(data),network::error);	BOOST_CHECK_THROW(receive(data),network::error);	delete_random_sendfile(file);}

 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 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 RunCreate(const int64_t& num){    CheckCreateInt(num);    CScriptNum scriptnum(num);    if (scriptnum.getvch().size() <= CScriptNum::nMaxNumSize)        CheckCreateVch(num);    else    {        BOOST_CHECK_THROW (CheckCreateVch(num), scriptnum_error);    }}

BOOST_FIXTURE_TEST_CASE(FullName, DataIdentityFixture){  // Encoding pipeline  ndn::Data d(ndn::Name("/local/ndn/prefix"));  d.setContentType(tlv::ContentType_Blob);  d.setFreshnessPeriod(time::seconds(10));  d.setContent(Content1, sizeof(Content1));  BOOST_CHECK_THROW(d.getFullName(), Data::Error);  keyChain.sign(d, security::SigningInfo(security::SigningInfo::SIGNER_TYPE_CERT, certName));  Name fullName;  BOOST_REQUIRE_NO_THROW(fullName = d.getFullName());  BOOST_CHECK_EQUAL(d.getName().hasWire(), true);  BOOST_CHECK_EQUAL(fullName.hasWire(), false);  // check if name was properly cached  BOOST_CHECK_EQUAL(fullName.get(-1).value(), d.getFullName().get(-1).value());  // check FullName content  BOOST_REQUIRE_EQUAL(d.getName().size() + 1, fullName.size());  BOOST_CHECK_EQUAL_COLLECTIONS(d.getName().begin(), d.getName().end(),                                fullName.begin(), fullName.end() - 1);  BOOST_CHECK_EQUAL(fullName.get(-1).value_size(), 32);  // FullName should be reset after the next line  d.setFreshnessPeriod(time::seconds(100));  BOOST_CHECK_THROW(d.getFullName(), Data::Error);  // Decoding pipeline  d.wireDecode(Block(Data1, sizeof(Data1)));  BOOST_REQUIRE_NO_THROW(fullName = d.getFullName());  BOOST_CHECK_EQUAL(fullName.toUri(),    "/local/ndn/prefix/"    "sha256digest=28bad4b5275bd392dbb670c75cf0b66f13f7942b21e80f55c0e86b374753a548");}

		void ExpectActionFailure(Fn && action)		{			CCar clone(car);			BOOST_CHECK_THROW(action(), std::exception);			BOOST_REQUIRE_EQUAL(clone.IsEngineOn(), car.IsEngineOn());			if (clone.IsEngineOn())			{				BOOST_CHECK(clone.GetDirection() == car.GetDirection());				BOOST_CHECK(clone.GetGear() == car.GetGear());				BOOST_CHECK(clone.GetSpeed() == car.GetSpeed());			}		}

    BrokerPtr createBroker(zeroeq::Subscriber& subscriber) override    {        BOOST_CHECK_THROW(new zeroeq::connection::Broker(                              "zeroeq::connection::test_named_broker",                              subscriber,                              zeroeq::connection::Broker::PORT_FIXED),                          std::runtime_error);        return BrokerPtr(new zeroeq::connection::Broker(            "zeroeq::connection::test_named_broker", subscriber,            zeroeq::connection::Broker::PORT_FIXED_OR_RANDOM));    }

BOOST_AUTO_TEST_CASE_TEMPLATE(members, T, float_types) {	vmath::core::Quaternion<T> H;	H.x = static_cast<T>(20.12);	H.y = static_cast<T>(100.89);	H.z = static_cast<T>(-18.2);	H.w = static_cast<T>(35.62);	BOOST_CHECK_CLOSE(H[0], H.x, 1e-4f);	BOOST_CHECK_CLOSE(H[1], H.y, 1e-4f);	BOOST_CHECK_CLOSE(H[2], H.z, 1e-4f);	BOOST_CHECK_CLOSE(H[3], H.w, 1e-4f);	H[0] = static_cast<T>(100.89);	H[1] = static_cast<T>(-18.2);	H[2] = static_cast<T>(35.62);	H[3] = static_cast<T>(20.12);	BOOST_CHECK_CLOSE(H[0], H.x, 1e-4f);	BOOST_CHECK_CLOSE(H[1], H.y, 1e-4f);	BOOST_CHECK_CLOSE(H[2], H.z, 1e-4f);	BOOST_CHECK_CLOSE(H[3], H.w, 1e-4f);	// invalid index	BOOST_CHECK_THROW(H[4], std::out_of_range);	BOOST_CHECK_THROW(H[4] = static_cast<T>(0.0), std::out_of_range);}

BOOST_AUTO_TEST_CASE_TEMPLATE( DeleteUnsupported, SorterT, sorter_types ){  keyvi::dictionary::compiler_param_t params = {};  keyvi::dictionary::DictionaryCompiler<            fsa::internal::SparseArrayPersistence<uint16_t>,            fsa::internal::JsonValueStore,            SorterT> compiler(10485760, params);  // add, delete, add again  compiler.Add("aa", "1");  BOOST_CHECK_THROW( compiler.Delete("aa"), compiler_exception);}

  void MotorDriverCardDummyTest::testGetMotorControler() {    boost::shared_ptr<MotorControler> controler0 = _motorDriverCardDummy.getMotorControler(0);    BOOST_CHECK(controler0->getID() == 0);    // check that we actually get a MotorControlerDummy    boost::shared_ptr<MotorControlerDummy> controler1 =        boost::dynamic_pointer_cast<MotorControlerDummy>(_motorDriverCardDummy.getMotorControler(1));    // this will cause an exception if the cast failed    BOOST_CHECK(controler1->getID() == 1);    BOOST_CHECK_THROW(_motorDriverCardDummy.getMotorControler(2), MotorDriverException);  }

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);}

	void CDatabaseFixedPointTest::TestCase_FixedPointAddition()	{		CLogger::LogInfo( StringStream() << "**** Start TestCase_FixedPointAddition ****" );		CFixedPoint a, b, c;		CLogger::LogInfo( StringStream() << "    No overflow" );		a = CFixedPoint( 996, 3, 0 );		b = CFixedPoint( 3, 3, 0 );		BOOST_CHECK_EQUAL( a + b, CFixedPoint( 999, 3, 0 ) );		CLogger::LogInfo( StringStream() << "    Precision overflow" );		b = CFixedPoint( 4, 3, 0 );		BOOST_CHECK_THROW( a + b, CDatabaseException );		CLogger::LogInfo( StringStream() << "    Integer overflow" );		c = CFixedPoint( 3, CFixedPoint::GetMaxPrecision(), 0 );		b = CFixedPoint( std::numeric_limits< int64_t >::max() - 2, CFixedPoint::GetMaxPrecision(), 0 );		BOOST_CHECK_THROW( c + b, CDatabaseException );		CLogger::LogInfo( StringStream() << "    Different precisions" );		b = CFixedPoint( 55, 5, 2 );		a = CFixedPoint( 334, 3, 1 );		BOOST_CHECK_EQUAL( a + b, CFixedPoint( 339, 3, 1 ) );		CLogger::LogInfo( StringStream() << "**** End TestCase_FixedPointAddition ****" );	}

	void test_identifier() {		// TODO: Check for correct message.		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"", ssm), excp::MalformedURLException);		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/a/0/0.png", ssm), excp::MalformedURLException);		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/-2/0.png", ssm), excp::MalformedURLException);		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/a.png", ssm), excp::MalformedURLException);		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/apng", ssm), excp::MalformedURLException);		BOOST_CHECK_THROW(TileIdentifier::Create((const string&)"/stylesheet/0/0/0.wrong", ssm), excp::UnknownImageFormatException);	}

BOOST_AUTO_TEST_CASE_TEMPLATE( adjacent_difference, DeviceType,                               DTK_SEARCH_DEVICE_TYPES ){    Kokkos::View<int[5], DeviceType> v( "v" );    auto v_host = Kokkos::create_mirror_view( v );    v_host( 0 ) = 2;    v_host( 1 ) = 4;    v_host( 2 ) = 6;    v_host( 3 ) = 8;    v_host( 4 ) = 10;    Kokkos::deep_copy( v, v_host );    // In-place operation is not allowed    BOOST_CHECK_THROW( ArborX::adjacentDifference( v, v ),                       ArborX::SearchException );    auto w = Kokkos::create_mirror( DeviceType(), v );    BOOST_CHECK_NO_THROW( ArborX::adjacentDifference( v, w ) );    auto w_host = Kokkos::create_mirror_view( w );    Kokkos::deep_copy( w_host, w );    std::vector<int> w_ref( 5, 2 );    BOOST_TEST( w_host == w_ref, tt::per_element() );    Kokkos::View<float *, DeviceType> x( "x", 10 );    Kokkos::deep_copy( x, 3.14 );    BOOST_CHECK_THROW( ArborX::adjacentDifference( x, x ),                       ArborX::SearchException );    Kokkos::View<float[10], DeviceType> y( "y" );    BOOST_CHECK_NO_THROW( ArborX::adjacentDifference( x, y ) );    std::vector<float> y_ref( 10 );    y_ref[0] = 3.14;    auto y_host = Kokkos::create_mirror_view( y );    Kokkos::deep_copy( y_host, y );    BOOST_TEST( y_host == y_ref, tt::per_element() );    Kokkos::resize( x, 5 );    BOOST_CHECK_THROW( ArborX::adjacentDifference( y, x ),                       ArborX::SearchException );}

void task4_6::tests_::solution_constructor_tests(){    task4_6::lines lines;    BOOST_CHECK_NO_THROW( solution s( lines ) );    {        lines.push_back( "A = 5 + ( 45 - 54 * 23 ) * C ");        BOOST_CHECK_THROW( solution s( lines ), std::logic_error );        lines.clear();    }    {        lines.push_back( "A = 5 + ( 45 - 54 * 23 )");        lines.push_back( "B = 15 / 23 )");        BOOST_CHECK_THROW( solution s( lines ), std::logic_error );        lines.clear();    }    {        lines.push_back( "A = 5 + ( 45 - 54 * 23 )");        lines.push_back( "B = 15 / 15");        lines.push_back( "C = A + B");        lines.push_back( "C = 45 + 65");        BOOST_CHECK_THROW( solution s( lines ), std::logic_error );        lines.clear();    }    {        lines.push_back( "A = 56 / 0 ");        BOOST_CHECK_THROW( solution s( lines ), std::logic_error );        lines.clear();    }    {        lines.push_back( "A = 45 + + 76");        BOOST_CHECK_THROW( solution s( lines ), std::logic_error );        lines.clear();    }}

void test_case_1(){	tsk::spin::unbounded_channel< int > buf;	BOOST_CHECK_EQUAL( true, buf.empty() );	BOOST_CHECK_EQUAL( true, buf.active() );	int n = 1;	buf.put( n);	BOOST_CHECK_EQUAL( false, buf.empty() );	boost::optional< int > res;	BOOST_CHECK_EQUAL( true, buf.take( res) );	BOOST_CHECK( res);	BOOST_CHECK_EQUAL( n, res.get() );	buf.deactivate();	BOOST_CHECK_EQUAL( false, buf.active() );	BOOST_CHECK_THROW( buf.put( 1), std::runtime_error);}

void task4_4::tests_::a_message_constructor_tests(){	std::stringstream test_stream;	BOOST_CHECK_THROW( a_message::create_message( test_stream ), std::logic_error );	test_stream.clear();	test_stream << "0123456789123456";	BOOST_CHECK_NO_THROW( a_message::create_message( test_stream ) );	test_stream << "0123456789123456";	message_ptr message = a_message::create_message( test_stream );		BOOST_CHECK_EQUAL( message->type(), 'A' );	BOOST_CHECK_EQUAL( message->str(), "a_message(0123456789123456)" );}

void multicast_communication::tests_::quote_message_tests(){	quote_message_ptr msg_ptr( new quote_message( &quote_callback ) );	std::ifstream test_input( SOURCE_DIR "/tests/data/quote_tests.txt" );	std::string msg;	std::getline( test_input, msg );	test_input.close();	std::stringstream stream( msg.substr( 1 ) );	BOOST_CHECK_NO_THROW( msg_ptr->parse( stream ) );	std::stringstream error_stream( "Error message" );	BOOST_CHECK_THROW( msg_ptr->parse( error_stream ), std::exception );}