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 ); }
TEST_F(TaskTest, GetTaskWithInvalidIdThrows) { auto invalid_id = ews::item_id(); EXPECT_THROW(service().get_task(invalid_id), ews::exchange_error); }
TEST_F(lagi_util, UtilRenameExNotFound) { EXPECT_THROW(util::Rename("./data/nonexistent", ""), FileNotFoundError); }
TEST(TrackerTest, MadeUpURL) { // Made up tracker URL madeUp("udp://barneysTracker.com:1234"); EXPECT_THROW(new Tracker(&madeUp), InvalidTracker); }
TEST_F(TestVariant, MinLimitUnknown) { EXPECT_THROW(vmf::Variant::minLimit<vmf::vmf_integer>(vmf::Variant::type_unknown), vmf::IncorrectParamException); }
TEST(bash_ast, parse_illegal_script) { EXPECT_THROW(bash_ast ast(get_src_dir() + std::string("/scripts/illegal_script.sh")), libbash::parse_exception); }
TEST(Sound, LoadMissingFileExpectException) { EXPECT_THROW(mono::AudioFactory::LoadFile("whatever.asdf"), std::runtime_error); }
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); }
TEST_F(connected_test, delete_exchange_notexist) { EXPECT_THROW(channel->DeleteExchange("exchange_notexist"), ChannelException); }
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()); } }
TEST(CacheTest, MissingValue) { cache::lru_cache<int, int> cache_lru(1); EXPECT_THROW(cache_lru.get(7), std::range_error); }
TEST_F(IfTest, Value) { EXPECT_THROW(testRule->value(*startState), runtime_error); }
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); }
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); }
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); }
TEST_F(connected_test, unbind_exchange_badbinding) { EXPECT_THROW(channel->UnbindExchange("exchange_notexist", "exchange_notexist", "notexist"), ChannelException); }
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); }
TEST_F(connected_test, declare_exchange_passive_notexist) { EXPECT_THROW(channel->DeclareExchange("declare_passive_notexist", Channel::EXCHANGE_TYPE_DIRECT, true), ChannelException); }
TEST(bash_ast, illegal_path) { EXPECT_THROW(bash_ast("not_exist"), libbash::parse_exception); }
TEST_F(PeriodicActionPoolTest, no_threads) { EXPECT_THROW(PeriodicActionPool::create("TestPool", 0), std::exception); }
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); }
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); } }
TEST(TrackerTest, TCP) { // No TCP Tracker support currently URL tcp("tcp://localhost:6881"); EXPECT_THROW(new Tracker(&tcp), InvalidTracker); }
TEST(lagi_format, bad_cast) { EXPECT_THROW(agi::format("%d", "hello"), std::bad_cast); EXPECT_THROW(agi::format("%.*s", "hello", "str"), std::bad_cast); }
TEST_F(TestVariant, ConvertInc) { v = vmf::Variant((vmf::vmf_real) 42.42); EXPECT_THROW(v.convertTo(vmf::Variant::type_string), vmf::TypeCastException); }
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"; }
TEST_F(lagi_util, UtilfreespaceNoAccess) { std::string path("./data/dir_access_denied"); EXPECT_THROW(util::freespace(path), acs::Read); }
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()); }
TEST(BuildersFactory, Unknown) { EXPECT_THROW(cpp_redis::builders::create_builder('a'), cpp_redis::redis_error); }
TEST_F(OperatorsTableScanStringTest, ScanLikeNonStringColumn) { auto scan = create_table_scan(_gt, ColumnID{0}, PredicateCondition::Like, "%test"); EXPECT_THROW(scan->execute(), std::exception); }