コード例 #1
1
TEST( MethodBuilderTests, theTest )
{
	co::RefPtr<co::ITypeBuilder> typeBuilder = TestHelper::createBuilder( co::TK_INTERFACE, "MethodBuilderbuilderTest.NewInterface" );

	co::IType* stringType = TestHelper::type( "string" );

	co::RefPtr<co::ITypeBuilder> exbuilder = TestHelper::createBuilder( co::TK_EXCEPTION, "MethodBuilderbuilderTest.NewException" );
	co::IException* testException = co::cast<co::IException>( exbuilder->createType() );

	co::RefPtr<co::IMethodBuilder> mb = typeBuilder->defineMethod( "testMethod" );

	EXPECT_THROW( mb->defineException( NULL ), co::IllegalArgumentException );
	EXPECT_THROW( mb->defineReturnType( NULL ), co::IllegalArgumentException );
	EXPECT_THROW( mb->defineParameter( "ok", NULL, true, true ) , co::IllegalArgumentException );
	EXPECT_THROW( mb->defineParameter( "ok", stringType, false, false ) , co::IllegalArgumentException );

	mb->defineParameter( "p1", stringType, false, true );
	mb->defineParameter( "p2", stringType, true, true );
	mb->defineParameter( "p3", stringType, true, false );

	mb->defineException( testException );

	mb->defineReturnType( stringType );

	EXPECT_THROW( mb->defineParameter( "p1", stringType, true, false ) , co::IllegalNameException ); // clash

	EXPECT_NO_THROW( mb->createMethod() );

	co::IInterface* itf = co::cast<co::IInterface>( typeBuilder->createType() );
	ASSERT_TRUE( itf != NULL );

	co::IMethod* mInfo = co::cast<co::IMethod>( itf->getMember( "testMethod" ) );
	ASSERT_TRUE( mInfo != NULL );

	ASSERT_EQ( 3, mInfo->getParameters().getSize() );

	co::Range<co::IParameter* const> params = mInfo->getParameters();
	co::IParameter* p = params.getFirst();
	ASSERT_EQ( "p1", p->getName() );
	ASSERT_EQ( stringType, p->getType() );
	ASSERT_FALSE( p->getIsIn() );
	ASSERT_TRUE( p->getIsOut() );

	params.popFirst();
	p = params.getFirst();
	ASSERT_EQ( "p2", p->getName() );
	ASSERT_EQ( stringType, p->getType() );
	ASSERT_TRUE( p->getIsIn() );
	ASSERT_TRUE( p->getIsOut() );

	params.popFirst();
	p = params.getFirst();
	ASSERT_EQ( "p3", p->getName() );
	ASSERT_EQ( stringType, p->getType() );
	ASSERT_TRUE( p->getIsIn() );
	ASSERT_FALSE( p->getIsOut() );

	ASSERT_EQ( stringType, mInfo->getReturnType() );

	ASSERT_EQ( testException , mInfo->getExceptions().getFirst() );

	EXPECT_NO_THROW( co::getSystem()->getTypes()->getTransaction()->commit() );

	EXPECT_THROW( mb->createMethod(), co::NotSupportedException );
}
コード例 #2
0
ファイル: test_tasks.cpp プロジェクト: PhilippRo/ews-cpp
 TEST_F(TaskTest, GetTaskWithInvalidIdThrows)
 {
     auto invalid_id = ews::item_id();
     EXPECT_THROW(service().get_task(invalid_id), ews::exchange_error);
 }
コード例 #3
0
TEST_F(lagi_util, UtilRenameExNotFound) {
	EXPECT_THROW(util::Rename("./data/nonexistent", ""), FileNotFoundError);
}
コード例 #4
0
ファイル: TrackerTest.cpp プロジェクト: barnabycolby/Magneto
TEST(TrackerTest, MadeUpURL)
{
	// Made up tracker
	URL madeUp("udp://barneysTracker.com:1234");
	EXPECT_THROW(new Tracker(&madeUp), InvalidTracker);
}
コード例 #5
0
ファイル: test_variant.cpp プロジェクト: SSE4/vmf-1
TEST_F(TestVariant, MinLimitUnknown)
{
    EXPECT_THROW(vmf::Variant::minLimit<vmf::vmf_integer>(vmf::Variant::type_unknown), vmf::IncorrectParamException);
}
コード例 #6
0
ファイル: bash_ast_test.cpp プロジェクト: Aparicio99/libbash
TEST(bash_ast, parse_illegal_script)
{
  EXPECT_THROW(bash_ast ast(get_src_dir() + std::string("/scripts/illegal_script.sh")), libbash::parse_exception);
}
コード例 #7
0
TEST(Sound, LoadMissingFileExpectException)
{
    EXPECT_THROW(mono::AudioFactory::LoadFile("whatever.asdf"), std::runtime_error);
}
コード例 #8
0
ファイル: PlatformImpTest.cpp プロジェクト: cmcantalupo/geopm
TEST_F(PlatformImpTest, negative_msr_write_bad_value)
{
    // The write mask specified in the constructor is 0 from bits 63:60 and 1 from bits 59:0.
    EXPECT_THROW(m_platform->msr_write(geopm::GEOPM_DOMAIN_CPU, 0, "MSR_TEST_0", 0xF000000000000000),
        geopm::Exception);
}
コード例 #9
0
TEST_F(connected_test, delete_exchange_notexist) {
  EXPECT_THROW(channel->DeleteExchange("exchange_notexist"), ChannelException);
}
コード例 #10
0
ファイル: Column_test.cpp プロジェクト: wio-pm/wio-sqlitecpp
TEST(Column, basis) {
    // Create a new database
    SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE);
    EXPECT_EQ(SQLite::OK, db.getErrorCode());
    EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode());

    // Create a new table
    EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL, binary BLOB, empty TEXT)"));
    EXPECT_TRUE(db.tableExists("test"));
    EXPECT_TRUE(db.tableExists(std::string("test")));
    EXPECT_EQ(0, db.getLastInsertRowid());

    // Create a first row (autoid: 1) with all kind of data and a null value
    SQLite::Statement   insert(db, "INSERT INTO test VALUES (NULL, \"first\", -123, 0.123, ?, NULL)");
    // Bind the blob value to the first parameter of the SQL query
    const char  buffer[] = {'b', 'l', '\0', 'b'}; // "bl\0b" : 4 char, with a null byte inside
    const int   size = sizeof(buffer); // size = 4
    const void* blob = &buffer;
    insert.bind(1, blob, size);
    // Execute the one-step query to insert the row
    EXPECT_EQ(1, insert.exec());
    EXPECT_EQ(1, db.getLastInsertRowid());
    EXPECT_EQ(1, db.getTotalChanges());

    EXPECT_THROW(insert.exec(), SQLite::Exception); // exec() shall throw as it needs to be reseted

    // Compile a SQL query
    SQLite::Statement   query(db, "SELECT * FROM test");
    EXPECT_STREQ("SELECT * FROM test", query.getQuery().c_str());
    EXPECT_EQ(6, query.getColumnCount ());
    query.executeStep();
    EXPECT_TRUE (query.hasRow());
    EXPECT_FALSE(query.isDone());

    // validates every variant of cast operators, and conversions of types
    {
        const sqlite3_int64 id1     = query.getColumn(0); // operator int64_t()
        const int64_t       id2     = query.getColumn(0); // operator int64_t()
        const long long     id3     = query.getColumn(0); // operator int64_t()
        const long          id4     = query.getColumn(0); // operator int64_t() or long() depending on compiler/architecture
        const unsigned int  uint1   = query.getColumn(0); // operator uint32_t()
        const uint32_t      uint2   = query.getColumn(0); // operator uint32_t()
        const char*         ptxt    = query.getColumn(1); // operator const char*()
        const std::string   msg     = query.getColumn(1); // operator std::string() (or const char* with MSVC)
        const int           integer = query.getColumn(2); // operator int()
        const double        real    = query.getColumn(3); // operator double()
        const void*         pblob   = query.getColumn(4); // operator void*()
        const std::string   sblob   = query.getColumn(4); // operator std::string() (or const char* with MSVC)
        const void*         pempty  = query.getColumn(5); // operator void*()
        EXPECT_EQ(1,            id1);
        EXPECT_EQ(1,            id2);
        EXPECT_EQ(1,            id3);
        EXPECT_EQ(1,            id4);
        EXPECT_EQ(1U,           uint1);
        EXPECT_EQ(1U,           uint2);
        EXPECT_STREQ("first",   ptxt);
        EXPECT_EQ("first",      msg);
        EXPECT_EQ(-123,         integer);
        EXPECT_EQ(0.123,        real);
        EXPECT_EQ(0,            memcmp("bl\0b", pblob, size));
        EXPECT_EQ((size_t)size, sblob.size());
        EXPECT_EQ(0,            memcmp("bl\0b", &sblob[0], size));
        EXPECT_EQ(NULL,         pempty);
    }

    // validates every variant of explicit getters
    {
        int64_t             id      = query.getColumn(0).getInt64();
        const unsigned int  uint1   = query.getColumn(0).getUInt();
        const uint32_t      uint2   = query.getColumn(0).getUInt();
        const char*         ptxt    = query.getColumn(1).getText();
        const std::string   msg1    = query.getColumn(1).getText();
        const std::string   msg2    = query.getColumn(1).getString();
        const int           integer = query.getColumn(2).getInt();
        const double        real    = query.getColumn(3).getDouble();
        const void*         pblob   = query.getColumn(4).getBlob();
        const std::string   sblob   = query.getColumn(4).getString();
        EXPECT_EQ(1,            id);
        EXPECT_EQ(1U,           uint1);
        EXPECT_EQ(1U,           uint2);
        EXPECT_STREQ("first",   ptxt);
        EXPECT_EQ("first",      msg1);
        EXPECT_EQ("first",      msg2);
        EXPECT_EQ(-123,         integer);
        EXPECT_EQ(0.123,        real);
        EXPECT_EQ(0,            memcmp("bl\0b", pblob, 4));
        EXPECT_EQ(0,            memcmp("bl\0b", &sblob[0], 4));
    }

    // Validate getBytes(), getType(), isInteger(), isNull()...
    EXPECT_EQ(SQLite::INTEGER,  query.getColumn(0).getType());
    EXPECT_EQ(true,             query.getColumn(0).isInteger());
    EXPECT_EQ(false,            query.getColumn(0).isFloat());
    EXPECT_EQ(false,            query.getColumn(0).isText());
    EXPECT_EQ(false,            query.getColumn(0).isBlob());
    EXPECT_EQ(false,            query.getColumn(0).isNull());
    EXPECT_STREQ("1",           query.getColumn(0).getText());  // convert to string
    EXPECT_EQ(1,                query.getColumn(0).getBytes()); // size of the string "1" without the null terminator
    EXPECT_EQ(SQLite::TEXT,     query.getColumn(1).getType());
    EXPECT_EQ(false,            query.getColumn(1).isInteger());
    EXPECT_EQ(false,            query.getColumn(1).isFloat());
    EXPECT_EQ(true,             query.getColumn(1).isText());
    EXPECT_EQ(false,            query.getColumn(1).isBlob());
    EXPECT_EQ(false,            query.getColumn(1).isNull());
    EXPECT_STREQ("first",       query.getColumn(1).getText());  // convert to string
    EXPECT_EQ(5,                query.getColumn(1).getBytes()); // size of the string "first"
    EXPECT_EQ(SQLite::INTEGER,  query.getColumn(2).getType());
    EXPECT_EQ(true,             query.getColumn(2).isInteger());
    EXPECT_EQ(false,            query.getColumn(2).isFloat());
    EXPECT_EQ(false,            query.getColumn(2).isText());
    EXPECT_EQ(false,            query.getColumn(2).isBlob());
    EXPECT_EQ(false,            query.getColumn(2).isNull());
    EXPECT_STREQ("-123",        query.getColumn(2).getText());  // convert to string
    EXPECT_EQ(4,                query.getColumn(2).getBytes()); // size of the string "-123"
    EXPECT_EQ(SQLite::FLOAT,    query.getColumn(3).getType());
    EXPECT_EQ(false,            query.getColumn(3).isInteger());
    EXPECT_EQ(true,             query.getColumn(3).isFloat());
    EXPECT_EQ(false,            query.getColumn(3).isText());
    EXPECT_EQ(false,            query.getColumn(3).isBlob());
    EXPECT_EQ(false,            query.getColumn(3).isNull());
    EXPECT_STREQ("0.123",       query.getColumn(3).getText());  // convert to string
    EXPECT_EQ(5,                query.getColumn(3).getBytes()); // size of the string "0.123"
    EXPECT_EQ(SQLite::BLOB,     query.getColumn(4).getType());
    EXPECT_EQ(false,            query.getColumn(4).isInteger());
    EXPECT_EQ(false,            query.getColumn(4).isFloat());
    EXPECT_EQ(false,            query.getColumn(4).isText());
    EXPECT_EQ(true,             query.getColumn(4).isBlob());
    EXPECT_EQ(false,            query.getColumn(4).isNull());
    EXPECT_STREQ("bl\0b",       query.getColumn(4).getText());  // convert to string
    EXPECT_EQ(4,                query.getColumn(4).getBytes()); // size of the blob "bl\0b" with the null char
    EXPECT_EQ(SQLite::Null,     query.getColumn(5).getType());
    EXPECT_EQ(false,            query.getColumn(5).isInteger());
    EXPECT_EQ(false,            query.getColumn(5).isFloat());
    EXPECT_EQ(false,            query.getColumn(5).isText());
    EXPECT_EQ(false,            query.getColumn(5).isBlob());
    EXPECT_EQ(true,             query.getColumn(5).isNull());
    EXPECT_STREQ("",            query.getColumn(5).getText());  // convert to string
    EXPECT_EQ(0,                query.getColumn(5).getBytes()); // size of the string "" without the null terminator

    // Use intermediate Column objects (this is not the recommended way to use the API)
    {
        const SQLite::Column id = query.getColumn(0);
        EXPECT_EQ(1, id.getInt64());
        const SQLite::Column msg = query.getColumn(1);
        EXPECT_EQ("first", msg.getString());
        const SQLite::Column integer = query.getColumn(2);
        EXPECT_EQ(-123, integer.getInt());
        const SQLite::Column dbl = query.getColumn(3);
        EXPECT_EQ(0.123, dbl.getDouble());
    }
}
コード例 #11
0
TEST(CacheTest, MissingValue) {
    cache::lru_cache<int, int> cache_lru(1);
    EXPECT_THROW(cache_lru.get(7), std::range_error);
}
コード例 #12
0
TEST_F(IfTest, Value)
{
	EXPECT_THROW(testRule->value(*startState), runtime_error);
}
コード例 #13
0
ファイル: CoreTests.cpp プロジェクト: smistad/SIPL
TEST(CoreTests, VolumeOutOfBounds) {
    Volume<char> * image = new Volume<char>(10,10, 10);

    // Getters
    EXPECT_THROW(image->get(-1), OutOfBoundsException);
    EXPECT_THROW(image->get(10*10*10), OutOfBoundsException);
    EXPECT_THROW(image->get(-4, 4, 2), OutOfBoundsException);
    EXPECT_THROW(image->get(-1,-10, 0), OutOfBoundsException);
    EXPECT_THROW(image->get(10, 0, 0), OutOfBoundsException);
    EXPECT_THROW(image->get(2, 1, -1), OutOfBoundsException);
    EXPECT_THROW(image->get(int3(-1, 4, 0)), OutOfBoundsException);
    EXPECT_THROW(image->get(int3(0, 200, 2)), OutOfBoundsException);
    EXPECT_THROW(image->get(Region(11, 11, 1)), OutOfBoundsException);

    // Setters
    EXPECT_THROW(image->set(-1,1), OutOfBoundsException);
    EXPECT_THROW(image->set(10*10*10,1), OutOfBoundsException);
    EXPECT_THROW(image->set(-4, 4, 2,1), OutOfBoundsException);
    EXPECT_THROW(image->set(-1,-10, 0,1), OutOfBoundsException);
    EXPECT_THROW(image->set(10, 0, 0,1), OutOfBoundsException);
    EXPECT_THROW(image->set(2, 1, -1,1), OutOfBoundsException);
    EXPECT_THROW(image->set(int3(-1, 4, 0),1), OutOfBoundsException);
    EXPECT_THROW(image->set(int3(0, 200, 2),1), OutOfBoundsException);
    EXPECT_THROW(image->set(Region(11, 11, 1),1), OutOfBoundsException);
}
コード例 #14
0
ファイル: CoreTests.cpp プロジェクト: smistad/SIPL
TEST(CoreTests, ImageOutOfBounds) {
    Image<char> * image = new Image<char>(10,10);
    // Getters
    EXPECT_THROW(image->get(-1), OutOfBoundsException);
    EXPECT_THROW(image->get(10*10), OutOfBoundsException);
    EXPECT_THROW(image->get(-1, 4), OutOfBoundsException);
    EXPECT_THROW(image->get(-1,-10), OutOfBoundsException);
    EXPECT_THROW(image->get(10, 0), OutOfBoundsException);
    EXPECT_THROW(image->get(2, 200), OutOfBoundsException);
    EXPECT_THROW(image->get(int2(-1, 4)), OutOfBoundsException);
    EXPECT_THROW(image->get(int2(0, 200)), OutOfBoundsException);
    EXPECT_THROW(image->get(Region(11, 11)), OutOfBoundsException);

    // Setters
    EXPECT_THROW(image->set(-1, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(10*10, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(-1, 4, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(-1,-10, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(10, 0, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(2, 200, 1), OutOfBoundsException);
    EXPECT_THROW(image->set(int2(-1, 4), 1), OutOfBoundsException);
    EXPECT_THROW(image->set(int2(0, 200), 1), OutOfBoundsException);
    EXPECT_THROW(image->set(Region(11, 11), 1), OutOfBoundsException);
}
コード例 #15
0
ファイル: test_el_ids.cpp プロジェクト: gbiggs/tawara
TEST(ElIDStream, Read)
{
    std::stringstream buffer;
    tawara::ids::ReadResult r;
    // 1xxxxxxx
    buffer.put(0x80);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x80);
    EXPECT_EQ(r.second, 1);
    buffer.put(0x81);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x81);
    EXPECT_EQ(r.second, 1);
    buffer.put(0x97);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x97);
    EXPECT_EQ(r.second, 1);
    buffer.put(0xC0);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0xC0);
    EXPECT_EQ(r.second, 1);
    buffer.put(0xFE);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0xFE);
    EXPECT_EQ(r.second, 1);
    buffer.put(0xFF);
    EXPECT_THROW(tawara::ids::read(buffer), tawara::InvalidEBMLID);
    // 01xxxxxx xxxxxxxx
    buffer.put(0x40); buffer.put(0x00);;
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x4000);
    EXPECT_EQ(r.second, 2);
    buffer.put(0x40); buffer.put(0x01);;
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x4001);
    EXPECT_EQ(r.second, 2);
    buffer.put(0x4B); buffer.put(0x35);;
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x4B35);
    EXPECT_EQ(r.second, 2);
    buffer.put(0x7F); buffer.put(0xFE);;
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x7FFE);
    EXPECT_EQ(r.second, 2);
    buffer.put(0x7F); buffer.put(0xFF);;
    EXPECT_THROW(tawara::ids::read(buffer), tawara::InvalidEBMLID);
    /* Uncomment this if EBML IDs expand to 64 bits.
    // 00000001 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
    buffer.put(0x01);
    for (int ii(0); ii < 7; ii++)
    {
        buffer.put(0x00);
    }
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x0100000000000000);
    EXPECT_EQ(r.second, 8);
    buffer.put(0x01);
    for (int ii(0); ii < 6; ii++)
    {
        buffer.put(0x00);
    }
    buffer.put(0x01);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x0100000000000001);
    EXPECT_EQ(r.second, 8);
    buffer.put(0x01);
    for (int ii(0); ii < 6; ii++)
    {
        buffer.put(0xFF);
    }
    buffer.put(0xFE);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x01FFFFFFFFFFFFFE);
    EXPECT_EQ(r.second, 8);
    buffer.put(0x01);
    for (int ii(0); ii < 7; ii++)
    {
        buffer.put(0xFF);
    }
    EXPECT_THROW(tawara::ids::read(buffer), tawara::InvalidEBMLID);
    */
    // EBML tag
    buffer.put(0x1A); buffer.put(0x45); buffer.put(0xDF); buffer.put(0xA3);
    r = tawara::ids::read(buffer);
    EXPECT_EQ(r.first, 0x1A45DFA3);
    EXPECT_EQ(r.second, 4);
}
コード例 #16
0
TEST_F(connected_test, unbind_exchange_badbinding) {
  EXPECT_THROW(channel->UnbindExchange("exchange_notexist", "exchange_notexist",
                                       "notexist"),
               ChannelException);
}
コード例 #17
0
TEST(dynamic_num_filter, unknown_function) {
  std::map<std::string, std::string> params;
  EXPECT_THROW(
      dynamic_num_filter f(LIBNUM_FILTER_SAMPLE, "unknown_function", params),
      converter_exception);
}
コード例 #18
0
TEST_F(connected_test, declare_exchange_passive_notexist) {
  EXPECT_THROW(channel->DeclareExchange("declare_passive_notexist",
                                        Channel::EXCHANGE_TYPE_DIRECT, true),
               ChannelException);
}
コード例 #19
0
ファイル: bash_ast_test.cpp プロジェクト: Aparicio99/libbash
TEST(bash_ast, illegal_path)
{
  EXPECT_THROW(bash_ast("not_exist"), libbash::parse_exception);
}
コード例 #20
0
TEST_F(PeriodicActionPoolTest, no_threads)
{
    EXPECT_THROW(PeriodicActionPool::create("TestPool",
                                            0),
                 std::exception);
}
コード例 #21
0
ファイル: CudaAdapterTest.cpp プロジェクト: Berjiz/CuEira
TEST_F(CudaAdapterTest, HandleCudaStatus) {
  handleCudaStatus(cudaSuccess, "test");
  EXPECT_THROW(handleCudaStatus(cudaErrorMissingConfiguration, "test"), CudaException);
  EXPECT_THROW(handleCudaStatus(cudaErrorNoDevice, "test"), CudaException);
  EXPECT_THROW(handleCudaStatus(cudaErrorIncompatibleDriverContext, "test"), CudaException);
}
コード例 #22
0
ファイル: SSLContextTest.cpp プロジェクト: johnyxc/folly
TEST_F(SSLContextTest, TestLoadCertKey) {
  std::string certData, keyData, anotherKeyData;
  const char* certPath = "folly/io/async/test/certs/tests-cert.pem";
  const char* keyPath = "folly/io/async/test/certs/tests-key.pem";
  const char* anotherKeyPath = "folly/io/async/test/certs/client_key.pem";
  folly::readFile(certPath, certData);
  folly::readFile(keyPath, keyData);
  folly::readFile(anotherKeyPath, anotherKeyData);

  {
    SCOPED_TRACE("Valid cert/key pair from buffer");
    SSLContext tmpCtx;
    tmpCtx.loadCertificateFromBufferPEM(certData);
    tmpCtx.loadPrivateKeyFromBufferPEM(keyData);
    EXPECT_TRUE(tmpCtx.isCertKeyPairValid());
  }

  {
    SCOPED_TRACE("Valid cert/key pair from files");
    SSLContext tmpCtx;
    tmpCtx.loadCertificate(certPath);
    tmpCtx.loadPrivateKey(keyPath);
    EXPECT_TRUE(tmpCtx.isCertKeyPairValid());
  }

  {
    SCOPED_TRACE("Invalid cert/key pair from file. Load cert first");
    SSLContext tmpCtx;
    tmpCtx.loadCertificate(certPath);
    EXPECT_THROW(tmpCtx.loadPrivateKey(anotherKeyPath), std::runtime_error);
  }

  {
    SCOPED_TRACE("Invalid cert/key pair from file. Load key first");
    SSLContext tmpCtx;
    tmpCtx.loadPrivateKey(anotherKeyPath);
    tmpCtx.loadCertificate(certPath);
    EXPECT_FALSE(tmpCtx.isCertKeyPairValid());
  }

  {
    SCOPED_TRACE("Invalid key/cert pair from buf. Load cert first");
    SSLContext tmpCtx;
    tmpCtx.loadCertificateFromBufferPEM(certData);
    EXPECT_THROW(
        tmpCtx.loadPrivateKeyFromBufferPEM(anotherKeyData), std::runtime_error);
  }

  {
    SCOPED_TRACE("Invalid key/cert pair from buf. Load key first");
    SSLContext tmpCtx;
    tmpCtx.loadPrivateKeyFromBufferPEM(anotherKeyData);
    tmpCtx.loadCertificateFromBufferPEM(certData);
    EXPECT_FALSE(tmpCtx.isCertKeyPairValid());
  }

  {
    SCOPED_TRACE(
        "loadCertKeyPairFromBufferPEM() must throw when cert/key mismatch");
    SSLContext tmpCtx;
    EXPECT_THROW(
        tmpCtx.loadCertKeyPairFromBufferPEM(certData, anotherKeyData),
        std::runtime_error);
  }

  {
    SCOPED_TRACE(
        "loadCertKeyPairFromBufferPEM() must succeed when cert/key match");
    SSLContext tmpCtx;
    tmpCtx.loadCertKeyPairFromBufferPEM(certData, keyData);
  }

  {
    SCOPED_TRACE(
        "loadCertKeyPairFromFiles() must throw when cert/key mismatch");
    SSLContext tmpCtx;
    EXPECT_THROW(
        tmpCtx.loadCertKeyPairFromFiles(certPath, anotherKeyPath),
        std::runtime_error);
  }

  {
    SCOPED_TRACE("loadCertKeyPairFromFiles() must succeed when cert/key match");
    SSLContext tmpCtx;
    tmpCtx.loadCertKeyPairFromFiles(certPath, keyPath);
  }
}
コード例 #23
0
ファイル: TrackerTest.cpp プロジェクト: barnabycolby/Magneto
TEST(TrackerTest, TCP)
{
	// No TCP Tracker support currently
	URL tcp("tcp://localhost:6881");
	EXPECT_THROW(new Tracker(&tcp), InvalidTracker);
}
コード例 #24
0
ファイル: format.cpp プロジェクト: chenjide/Aegisub
TEST(lagi_format, bad_cast) {
    EXPECT_THROW(agi::format("%d", "hello"), std::bad_cast);
    EXPECT_THROW(agi::format("%.*s", "hello", "str"), std::bad_cast);
}
コード例 #25
0
ファイル: test_variant.cpp プロジェクト: SSE4/vmf-1
TEST_F(TestVariant, ConvertInc)
{
    v = vmf::Variant((vmf::vmf_real) 42.42);
    EXPECT_THROW(v.convertTo(vmf::Variant::type_string), vmf::TypeCastException);
}
コード例 #26
0
ファイル: test_el_ids.cpp プロジェクト: gbiggs/tawara
TEST(ElID, Decode)
{
    std::vector<char> buffer;
    tawara::ids::DecodeResult r;
    // 1xxxxxxx
    buffer.assign(1, 0x80);
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x80);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x81;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x81);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x97;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x97);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0xC0;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0xC0);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0xFE;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0xFE);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0xFF;
    EXPECT_THROW(tawara::ids::decode(buffer), tawara::InvalidEBMLID);
    // 01xxxxxx xxxxxxxx
    buffer.assign(2, 0);
    buffer[0] = 0x40;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x4000);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x40; buffer[1] = 0x01;;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x4001);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x4B; buffer[1] = 0x35;;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x4B35);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x7F; buffer[1] = 0xFE;;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x7FFE);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[0] = 0x7F; buffer[1] = 0xFF;;
    EXPECT_THROW(tawara::ids::decode(buffer), tawara::InvalidEBMLID);
    /* Uncomment this if EBML IDs expand to 64 bits.
    // 00000001 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
    buffer.assign(8, 0);
    buffer[0] = 0x01;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x0100000000000000);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[7] = 0x01;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x0100000000000001);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer.assign(8, 0xFF);
    buffer[0] = 0x01;
    buffer[7] = 0xFE;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x01FFFFFFFFFFFFFE);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
    buffer[7] = 0xFF;
    EXPECT_THROW(tawara::ids::decode(buffer), tawara::InvalidEBMLID);
    */
    // EBML tag
    buffer.assign(4, 0x1A);
    buffer[1] = 0x45; buffer[2] = 0xDF; buffer[3] = 0xA3;
    r = tawara::ids::decode(buffer);
    EXPECT_EQ(r.first, 0x1A45DFA3);
    EXPECT_TRUE(r.second == buffer.end()) << "Iterator not after data";
}
コード例 #27
0
TEST_F(lagi_util, UtilfreespaceNoAccess) {
	std::string path("./data/dir_access_denied");
	EXPECT_THROW(util::freespace(path), acs::Read);
}
コード例 #28
0
ファイル: test_el_ids.cpp プロジェクト: gbiggs/tawara
TEST(ElIDStream, Write)
{
    std::ostringstream buffer;
    std::ostringstream expected;
    // 1xxxxxxx
    expected.put(0x80);
    EXPECT_EQ(1, tawara::ids::write(0x80, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0x81);
    EXPECT_EQ(1, tawara::ids::write(0x81, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0x97);
    EXPECT_EQ(1, tawara::ids::write(0x97, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0xC0);
    EXPECT_EQ(1, tawara::ids::write(0xC0, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0xFE);
    EXPECT_EQ(1, tawara::ids::write(0xFE, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    EXPECT_THROW(tawara::ids::write(0xFF, buffer), tawara::InvalidEBMLID);
    // 01xxxxxx xxxxxxxx
    expected.put(0x40); expected.put(0x00);
    EXPECT_EQ(2, tawara::ids::write(0x4000, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0x4B); expected.put(0x35);
    EXPECT_EQ(2, tawara::ids::write(0x4B35, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    expected.put(0x7F); expected.put(0xFE);
    EXPECT_EQ(2, tawara::ids::write(0x7FFE, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    EXPECT_THROW(tawara::ids::write(0x7FFF, buffer), tawara::InvalidEBMLID);
    /* Uncomment this if EBML IDs expand to 64 bits.
    // 00000001 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
    expected.put(0x01);
    for (int ii(0); ii < 6; ii++)
    {
        expected.put(0xFF);
    }
    expected.put(0xFE);
    EXPECT_EQ(8, tawara::ids::write(0x01FFFFFFFFFFFFFE, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
    EXPECT_THROW(tawara::ids::write(0x01FFFFFFFFFFFFFF, buffer),
            tawara::InvalidEBMLID);
    */
    // EBML tag
    expected.put(0x1A); expected.put(0x45); expected.put(0xDF);
    expected.put(0xA3);
    EXPECT_EQ(4, tawara::ids::write(0x1A45DFA3, buffer));
    EXPECT_PRED_FORMAT2(test_utils::std_buffers_eq, expected.str(),
            buffer.str());
}
コード例 #29
0
TEST(BuildersFactory, Unknown) {
    EXPECT_THROW(cpp_redis::builders::create_builder('a'), cpp_redis::redis_error);
}
コード例 #30
0
TEST_F(OperatorsTableScanStringTest, ScanLikeNonStringColumn) {
  auto scan = create_table_scan(_gt, ColumnID{0}, PredicateCondition::Like, "%test");
  EXPECT_THROW(scan->execute(), std::exception);
}