namespace caffe {
-template <typename TypeParam>
-class DatabaseTest : public MultiDeviceTest<TypeParam> {
- typedef typename TypeParam::Dtype Dtype;
-
- protected:
- string DBName() {
- string filename;
- MakeTempDir(&filename);
- filename += "/db";
- return filename;
- }
-
- Database::key_type TestKey() {
- const char* kKey = "hello";
- Database::key_type key(kKey, kKey + 5);
- return key;
- }
-
- Database::value_type TestValue() {
- const char* kValue = "world";
- Database::value_type value(kValue, kValue + 5);
- return value;
- }
-
- Database::key_type TestAltKey() {
- const char* kKey = "foo";
- Database::key_type key(kKey, kKey + 3);
- return key;
- }
-
- Database::value_type TestAltValue() {
- const char* kValue = "bar";
- Database::value_type value(kValue, kValue + 3);
- return value;
- }
-
- template <typename T>
- bool BufferEq(const T& buf1, const T& buf2) {
- if (buf1.size() != buf2.size()) {
- return false;
- }
- for (size_t i = 0; i < buf1.size(); ++i) {
- if (buf1.at(i) != buf2.at(i)) {
- return false;
- }
- }
+namespace DatabaseTest_internal {
- return true;
- }
+template <typename T>
+struct TestData {
+ static T TestValue();
+ static T TestAltValue();
+ static bool equals(const T& a, const T& b);
};
-TYPED_TEST_CASE(DatabaseTest, TestDtypesAndDevices);
-
-TYPED_TEST(DatabaseTest, TestNewDoesntExistLevelDBPasses) {
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(this->DBName(), Database::New));
- database->close();
+template <>
+string TestData<string>::TestValue() {
+ return "world";
}
-TYPED_TEST(DatabaseTest, TestNewExistsFailsLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_FALSE(database->open(name, Database::New));
+template <>
+string TestData<string>::TestAltValue() {
+ return "bar";
}
-TYPED_TEST(DatabaseTest, TestReadOnlyExistsLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
- database->close();
+template <>
+bool TestData<string>::equals(const string& a, const string& b) {
+ return a == b;
}
-TYPED_TEST(DatabaseTest, TestReadOnlyDoesntExistFailsLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_FALSE(database->open(name, Database::ReadOnly));
-}
-
-TYPED_TEST(DatabaseTest, TestReadWriteExistsLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
- database->close();
+template <>
+vector<char> TestData<vector<char> >::TestValue() {
+ string str = "world";
+ vector<char> val(str.data(), str.data() + str.size());
+ return val;
}
-TYPED_TEST(DatabaseTest, TestReadWriteDoesntExistLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
- database->close();
+template <>
+vector<char> TestData<vector<char> >::TestAltValue() {
+ string str = "bar";
+ vector<char> val(str.data(), str.data() + str.size());
+ return val;
}
-TYPED_TEST(DatabaseTest, TestKeysLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key1 = this->TestKey();
- Database::value_type value1 = this->TestValue();
-
- EXPECT_TRUE(database->put(key1, value1));
-
- Database::key_type key2 = this->TestAltKey();
- Database::value_type value2 = this->TestAltValue();
-
- EXPECT_TRUE(database->put(key2, value2));
-
- EXPECT_TRUE(database->commit());
-
- vector<Database::key_type> keys;
- database->keys(&keys);
-
- EXPECT_EQ(2, keys.size());
-
- EXPECT_TRUE(this->BufferEq(keys.at(0), key1) ||
- this->BufferEq(keys.at(0), key2));
- EXPECT_TRUE(this->BufferEq(keys.at(1), key1) ||
- this->BufferEq(keys.at(2), key2));
- EXPECT_FALSE(this->BufferEq(keys.at(0), keys.at(1)));
-}
-
-TYPED_TEST(DatabaseTest, TestKeysNoCommitLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key1 = this->TestKey();
- Database::value_type value1 = this->TestValue();
-
- EXPECT_TRUE(database->put(key1, value1));
-
- Database::key_type key2 = this->TestAltKey();
- Database::value_type value2 = this->TestAltValue();
-
- EXPECT_TRUE(database->put(key2, value2));
-
- vector<Database::key_type> keys;
- database->keys(&keys);
-
- EXPECT_EQ(0, keys.size());
-}
-
-TYPED_TEST(DatabaseTest, TestIteratorsLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- const int kNumExamples = 4;
- for (int i = 0; i < kNumExamples; ++i) {
- stringstream ss;
- ss << i;
- string key = ss.str();
- ss << " here be data";
- string value = ss.str();
- Database::key_type key_buf(key.data(), key.data() + key.size());
- Database::value_type val_buf(value.data(), value.data() + value.size());
- EXPECT_TRUE(database->put(key_buf, val_buf));
+template <>
+bool TestData<vector<char> >::equals(const vector<char>& a,
+ const vector<char>& b) {
+ if (a.size() != b.size()) {
+ return false;
}
- EXPECT_TRUE(database->commit());
-
- int count = 0;
- for (Database::const_iterator iter = database->begin();
- iter != database->end(); ++iter) {
- (void)iter;
- ++count;
+ for (size_t i = 0; i < a.size(); ++i) {
+ if (a.at(i) != b.at(i)) {
+ return false;
+ }
}
- EXPECT_EQ(kNumExamples, count);
+ return true;
}
-TYPED_TEST(DatabaseTest, TestIteratorsPreIncrementLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key1 = this->TestAltKey();
- Database::value_type value1 = this->TestAltValue();
-
- Database::key_type key2 = this->TestKey();
- Database::value_type value2 = this->TestValue();
-
- EXPECT_TRUE(database->put(key1, value1));
- EXPECT_TRUE(database->put(key2, value2));
- EXPECT_TRUE(database->commit());
-
- Database::const_iterator iter1 = database->begin();
-
- EXPECT_FALSE(database->end() == iter1);
-
- EXPECT_TRUE(this->BufferEq(iter1->key, key1));
-
- Database::const_iterator iter2 = ++iter1;
-
- EXPECT_FALSE(database->end() == iter1);
- EXPECT_FALSE(database->end() == iter2);
-
- EXPECT_TRUE(this->BufferEq(iter2->key, key2));
-
- Database::const_iterator iter3 = ++iter2;
-
- EXPECT_TRUE(database->end() == iter3);
-
- database->close();
+template <>
+Datum TestData<Datum>::TestValue() {
+ Datum datum;
+ datum.set_channels(3);
+ datum.set_height(32);
+ datum.set_width(32);
+ datum.set_data(string(32 * 32 * 3 * 4, ' '));
+ datum.set_label(0);
+ return datum;
}
-TYPED_TEST(DatabaseTest, TestIteratorsPostIncrementLevelDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key1 = this->TestAltKey();
- Database::value_type value1 = this->TestAltValue();
-
- Database::key_type key2 = this->TestKey();
- Database::value_type value2 = this->TestValue();
-
- EXPECT_TRUE(database->put(key1, value1));
- EXPECT_TRUE(database->put(key2, value2));
- EXPECT_TRUE(database->commit());
-
- Database::const_iterator iter1 = database->begin();
-
- EXPECT_FALSE(database->end() == iter1);
-
- EXPECT_TRUE(this->BufferEq(iter1->key, key1));
-
- Database::const_iterator iter2 = iter1++;
-
- EXPECT_FALSE(database->end() == iter1);
- EXPECT_FALSE(database->end() == iter2);
-
- EXPECT_TRUE(this->BufferEq(iter2->key, key1));
- EXPECT_TRUE(this->BufferEq(iter1->key, key2));
-
- Database::const_iterator iter3 = iter1++;
-
- EXPECT_FALSE(database->end() == iter3);
- EXPECT_TRUE(this->BufferEq(iter3->key, key2));
- EXPECT_TRUE(database->end() == iter1);
-
- database->close();
-}
-
-TYPED_TEST(DatabaseTest, TestNewPutLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
-
- EXPECT_TRUE(database->commit());
-
- database->close();
+template <>
+Datum TestData<Datum>::TestAltValue() {
+ Datum datum;
+ datum.set_channels(1);
+ datum.set_height(64);
+ datum.set_width(64);
+ datum.set_data(string(64 * 64 * 1 * 4, ' '));
+ datum.set_label(1);
+ return datum;
}
-TYPED_TEST(DatabaseTest, TestNewCommitLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
+template <>
+bool TestData<Datum>::equals(const Datum& a, const Datum& b) {
+ string serialized_a;
+ a.SerializeToString(&serialized_a);
- EXPECT_TRUE(database->commit());
+ string serialized_b;
+ b.SerializeToString(&serialized_b);
- database->close();
+ return serialized_a == serialized_b;
}
-TYPED_TEST(DatabaseTest, TestNewGetLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
-
- EXPECT_TRUE(database->commit());
-
- Database::value_type new_val;
-
- EXPECT_TRUE(database->get(key, &new_val));
-
- EXPECT_TRUE(this->BufferEq(val, new_val));
-
- database->close();
-}
-
-TYPED_TEST(DatabaseTest, TestNewGetNoCommitLevelDBFails) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
+} // namespace DatabaseTest_internal
- Database::value_type new_val;
-
- EXPECT_FALSE(database->get(key, &new_val));
-}
+#define UNPACK_TYPES \
+ typedef typename TypeParam::value_type value_type; \
+ const DataParameter_DB backend = TypeParam::backend;
+template <typename TypeParam>
+class DatabaseTest : public ::testing::Test {
+ protected:
+ typedef typename TypeParam::value_type value_type;
-TYPED_TEST(DatabaseTest, TestReadWritePutLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
+ string DBName() {
+ string filename;
+ MakeTempDir(&filename);
+ filename += "/db";
+ return filename;
+ }
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string TestKey() {
+ return "hello";
+ }
- EXPECT_TRUE(database->put(key, val));
+ value_type TestValue() {
+ return DatabaseTest_internal::TestData<value_type>::TestValue();
+ }
- EXPECT_TRUE(database->commit());
+ string TestAltKey() {
+ return "foo";
+ }
- database->close();
-}
+ value_type TestAltValue() {
+ return DatabaseTest_internal::TestData<value_type>::TestAltValue();
+ }
-TYPED_TEST(DatabaseTest, TestReadWriteCommitLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
+ template <typename T>
+ bool equals(const T& a, const T& b) {
+ return DatabaseTest_internal::TestData<T>::equals(a, b);
+ }
+};
- EXPECT_TRUE(database->commit());
+struct StringLeveldb {
+ typedef string value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB StringLeveldb::backend = DataParameter_DB_LEVELDB;
- database->close();
-}
+struct StringLmdb {
+ typedef string value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB StringLmdb::backend = DataParameter_DB_LEVELDB;
-TYPED_TEST(DatabaseTest, TestReadWriteGetLevelDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
+struct VectorLeveldb {
+ typedef vector<char> value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB VectorLeveldb::backend = DataParameter_DB_LEVELDB;
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+struct VectorLmdb {
+ typedef vector<char> value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB VectorLmdb::backend = DataParameter_DB_LEVELDB;
- EXPECT_TRUE(database->put(key, val));
+struct DatumLeveldb {
+ typedef Datum value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB DatumLeveldb::backend = DataParameter_DB_LEVELDB;
- EXPECT_TRUE(database->commit());
+struct DatumLmdb {
+ typedef Datum value_type;
+ static const DataParameter_DB backend;
+};
+const DataParameter_DB DatumLmdb::backend = DataParameter_DB_LEVELDB;
- Database::value_type new_val;
+typedef ::testing::Types<StringLeveldb, StringLmdb, VectorLeveldb, VectorLmdb,
+ DatumLeveldb, DatumLmdb> TestTypes;
- EXPECT_TRUE(database->get(key, &new_val));
+TYPED_TEST_CASE(DatabaseTest, TestTypes);
- EXPECT_TRUE(this->BufferEq(val, new_val));
+TYPED_TEST(DatabaseTest, TestNewDoesntExistPasses) {
+ UNPACK_TYPES;
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(this->DBName(),
+ Database<string, value_type>::New));
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadWriteGetNoCommitLevelDBFails) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
-
- Database::value_type new_val;
-
- EXPECT_FALSE(database->get(key, &new_val));
-}
+TYPED_TEST(DatabaseTest, TestNewExistsFails) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestReadOnlyPutLevelDBFails) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_FALSE(database->put(key, val));
+ EXPECT_FALSE(database->open(name, Database<string, value_type>::New));
}
-TYPED_TEST(DatabaseTest, TestReadOnlyCommitLevelDBFails) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
-
- EXPECT_FALSE(database->commit());
-}
+TYPED_TEST(DatabaseTest, TestReadOnlyExistsPasses) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestReadOnlyGetLevelDBPasses) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
-
- EXPECT_TRUE(database->commit());
-
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
-
- Database::value_type new_val;
-
- EXPECT_TRUE(database->get(key, &new_val));
-
- EXPECT_TRUE(this->BufferEq(val, new_val));
-}
-
-TYPED_TEST(DatabaseTest, TestReadOnlyGetNoCommitLevelDBFails) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("leveldb");
- EXPECT_TRUE(database->open(name, Database::New));
-
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
-
- EXPECT_TRUE(database->put(key, val));
-
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadOnly));
database->close();
-
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
-
- Database::value_type new_val;
-
- EXPECT_FALSE(database->get(key, &new_val));
}
-TYPED_TEST(DatabaseTest, TestNewDoesntExistLMDBPasses) {
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(this->DBName(), Database::New));
- database->close();
-}
+TYPED_TEST(DatabaseTest, TestReadOnlyDoesntExistFails) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestNewExistsFailsLMDB) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_FALSE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_FALSE(database->open(name, Database<string, value_type>::ReadOnly));
}
-TYPED_TEST(DatabaseTest, TestReadOnlyExistsLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestReadWriteExistsPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadWrite));
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadOnlyDoesntExistFailsLMDB) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_FALSE(database->open(name, Database::ReadOnly));
-}
+TYPED_TEST(DatabaseTest, TestReadWriteDoesntExistPasses) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestReadWriteExistsLMDBPasses) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
- database->close();
-
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadWrite));
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadWriteDoesntExistLMDBPasses) {
- string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
- database->close();
-}
+TYPED_TEST(DatabaseTest, TestKeys) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestKeysLMDB) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key1 = this->TestKey();
- Database::value_type value1 = this->TestValue();
+ string key1 = this->TestKey();
+ value_type value1 = this->TestValue();
EXPECT_TRUE(database->put(key1, value1));
- Database::key_type key2 = this->TestAltKey();
- Database::value_type value2 = this->TestAltValue();
+ string key2 = this->TestAltKey();
+ value_type value2 = this->TestAltValue();
EXPECT_TRUE(database->put(key2, value2));
EXPECT_TRUE(database->commit());
- vector<Database::key_type> keys;
+ vector<string> keys;
database->keys(&keys);
EXPECT_EQ(2, keys.size());
- EXPECT_TRUE(this->BufferEq(keys.at(0), key1) ||
- this->BufferEq(keys.at(0), key2));
- EXPECT_TRUE(this->BufferEq(keys.at(1), key1) ||
- this->BufferEq(keys.at(2), key2));
- EXPECT_FALSE(this->BufferEq(keys.at(0), keys.at(1)));
+ EXPECT_TRUE(this->equals(keys.at(0), key1) ||
+ this->equals(keys.at(0), key2));
+ EXPECT_TRUE(this->equals(keys.at(1), key1) ||
+ this->equals(keys.at(2), key2));
+ EXPECT_FALSE(this->equals(keys.at(0), keys.at(1)));
}
-TYPED_TEST(DatabaseTest, TestKeysNoCommitLMDB) {
+TYPED_TEST(DatabaseTest, TestKeysNoCommit) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key1 = this->TestKey();
- Database::value_type value1 = this->TestValue();
+ string key1 = this->TestKey();
+ value_type value1 = this->TestValue();
EXPECT_TRUE(database->put(key1, value1));
- Database::key_type key2 = this->TestAltKey();
- Database::value_type value2 = this->TestAltValue();
+ string key2 = this->TestAltKey();
+ value_type value2 = this->TestAltValue();
EXPECT_TRUE(database->put(key2, value2));
- vector<Database::key_type> keys;
+ vector<string> keys;
database->keys(&keys);
EXPECT_EQ(0, keys.size());
}
+TYPED_TEST(DatabaseTest, TestIterators) {
+ UNPACK_TYPES;
-TYPED_TEST(DatabaseTest, TestIteratorsLMDB) {
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
const int kNumExamples = 4;
for (int i = 0; i < kNumExamples; ++i) {
ss << i;
string key = ss.str();
ss << " here be data";
- string value = ss.str();
- Database::key_type key_buf(key.data(), key.data() + key.size());
- Database::value_type val_buf(value.data(), value.data() + value.size());
- EXPECT_TRUE(database->put(key_buf, val_buf));
+ value_type value = this->TestValue();
+ EXPECT_TRUE(database->put(key, value));
}
EXPECT_TRUE(database->commit());
int count = 0;
- for (Database::const_iterator iter = database->begin();
- iter != database->end(); ++iter) {
+ typedef typename Database<string, value_type>::const_iterator Iter;
+ for (Iter iter = database->begin(); iter != database->end(); ++iter) {
(void)iter;
++count;
}
EXPECT_EQ(kNumExamples, count);
}
-TYPED_TEST(DatabaseTest, TestIteratorsPreIncrementLMDB) {
+TYPED_TEST(DatabaseTest, TestIteratorsPreIncrement) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key1 = this->TestAltKey();
- Database::value_type value1 = this->TestAltValue();
+ string key1 = this->TestAltKey();
+ value_type value1 = this->TestAltValue();
- Database::key_type key2 = this->TestKey();
- Database::value_type value2 = this->TestValue();
+ string key2 = this->TestKey();
+ value_type value2 = this->TestValue();
EXPECT_TRUE(database->put(key1, value1));
EXPECT_TRUE(database->put(key2, value2));
EXPECT_TRUE(database->commit());
- Database::const_iterator iter1 = database->begin();
+ typename Database<string, value_type>::const_iterator iter1 =
+ database->begin();
EXPECT_FALSE(database->end() == iter1);
- EXPECT_TRUE(this->BufferEq(iter1->key, key1));
+ EXPECT_TRUE(this->equals(iter1->key, key1));
- Database::const_iterator iter2 = ++iter1;
+ typename Database<string, value_type>::const_iterator iter2 = ++iter1;
EXPECT_FALSE(database->end() == iter1);
EXPECT_FALSE(database->end() == iter2);
- EXPECT_TRUE(this->BufferEq(iter2->key, key2));
+ EXPECT_TRUE(this->equals(iter2->key, key2));
- Database::const_iterator iter3 = ++iter2;
+ typename Database<string, value_type>::const_iterator iter3 = ++iter2;
EXPECT_TRUE(database->end() == iter3);
database->close();
}
-TYPED_TEST(DatabaseTest, TestIteratorsPostIncrementLMDB) {
+TYPED_TEST(DatabaseTest, TestIteratorsPostIncrement) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key1 = this->TestAltKey();
- Database::value_type value1 = this->TestAltValue();
+ string key1 = this->TestAltKey();
+ value_type value1 = this->TestAltValue();
- Database::key_type key2 = this->TestKey();
- Database::value_type value2 = this->TestValue();
+ string key2 = this->TestKey();
+ value_type value2 = this->TestValue();
EXPECT_TRUE(database->put(key1, value1));
EXPECT_TRUE(database->put(key2, value2));
EXPECT_TRUE(database->commit());
- Database::const_iterator iter1 = database->begin();
+ typename Database<string, value_type>::const_iterator iter1 =
+ database->begin();
EXPECT_FALSE(database->end() == iter1);
- EXPECT_TRUE(this->BufferEq(iter1->key, key1));
+ EXPECT_TRUE(this->equals(iter1->key, key1));
- Database::const_iterator iter2 = iter1++;
+ typename Database<string, value_type>::const_iterator iter2 = iter1++;
EXPECT_FALSE(database->end() == iter1);
EXPECT_FALSE(database->end() == iter2);
- EXPECT_TRUE(this->BufferEq(iter2->key, key1));
- EXPECT_TRUE(this->BufferEq(iter1->key, key2));
+ EXPECT_TRUE(this->equals(iter2->key, key1));
+ EXPECT_TRUE(this->equals(iter1->key, key2));
- Database::const_iterator iter3 = iter1++;
+ typename Database<string, value_type>::const_iterator iter3 = iter1++;
EXPECT_FALSE(database->end() == iter3);
- EXPECT_TRUE(this->BufferEq(iter3->key, key2));
+ EXPECT_TRUE(this->equals(iter3->key, key2));
EXPECT_TRUE(database->end() == iter1);
database->close();
}
-TYPED_TEST(DatabaseTest, TestNewPutLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestNewPutPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
EXPECT_TRUE(database->commit());
database->close();
}
-TYPED_TEST(DatabaseTest, TestNewCommitLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestNewCommitPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
EXPECT_TRUE(database->commit());
database->close();
}
-TYPED_TEST(DatabaseTest, TestNewGetLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestNewGetPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
EXPECT_TRUE(database->commit());
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_TRUE(database->get(key, &new_val));
+ EXPECT_TRUE(database->get(key, &new_value));
- EXPECT_TRUE(this->BufferEq(val, new_val));
+ EXPECT_TRUE(this->equals(value, new_value));
database->close();
}
-TYPED_TEST(DatabaseTest, TestNewGetNoCommitLMDBFails) {
+TYPED_TEST(DatabaseTest, TestNewGetNoCommitFails) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_FALSE(database->get(key, &new_val));
+ EXPECT_FALSE(database->get(key, &new_value));
}
-TYPED_TEST(DatabaseTest, TestReadWritePutLMDBPasses) {
+
+TYPED_TEST(DatabaseTest, TestReadWritePutPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadWrite));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
EXPECT_TRUE(database->commit());
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadWriteCommitLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestReadWriteCommitPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::ReadWrite));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadWrite));
EXPECT_TRUE(database->commit());
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadWriteGetLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestReadWriteGetPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
EXPECT_TRUE(database->commit());
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_TRUE(database->get(key, &new_val));
+ EXPECT_TRUE(database->get(key, &new_value));
- EXPECT_TRUE(this->BufferEq(val, new_val));
+ EXPECT_TRUE(this->equals(value, new_value));
database->close();
}
-TYPED_TEST(DatabaseTest, TestReadWriteGetNoCommitLMDBFails) {
+TYPED_TEST(DatabaseTest, TestReadWriteGetNoCommitFails) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_FALSE(database->get(key, &new_val));
+ EXPECT_FALSE(database->get(key, &new_value));
}
-TYPED_TEST(DatabaseTest, TestReadOnlyPutLMDBFails) {
+TYPED_TEST(DatabaseTest, TestReadOnlyPutFails) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadOnly));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_FALSE(database->put(key, val));
+ EXPECT_FALSE(database->put(key, value));
}
-TYPED_TEST(DatabaseTest, TestReadOnlyCommitLMDBFails) {
+TYPED_TEST(DatabaseTest, TestReadOnlyCommitFails) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadOnly));
EXPECT_FALSE(database->commit());
}
-TYPED_TEST(DatabaseTest, TestReadOnlyGetLMDBPasses) {
+TYPED_TEST(DatabaseTest, TestReadOnlyGetPasses) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
EXPECT_TRUE(database->commit());
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadOnly));
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_TRUE(database->get(key, &new_val));
+ EXPECT_TRUE(database->get(key, &new_value));
- EXPECT_TRUE(this->BufferEq(val, new_val));
+ EXPECT_TRUE(this->equals(value, new_value));
}
-TYPED_TEST(DatabaseTest, TestReadOnlyGetNoCommitLMDBFails) {
+TYPED_TEST(DatabaseTest, TestReadOnlyGetNoCommitFails) {
+ UNPACK_TYPES;
+
string name = this->DBName();
- shared_ptr<Database> database = DatabaseFactory("lmdb");
- EXPECT_TRUE(database->open(name, Database::New));
+ shared_ptr<Database<string, value_type> > database =
+ DatabaseFactory<string, value_type>(backend);
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::New));
- Database::key_type key = this->TestKey();
- Database::value_type val = this->TestValue();
+ string key = this->TestKey();
+ value_type value = this->TestValue();
- EXPECT_TRUE(database->put(key, val));
+ EXPECT_TRUE(database->put(key, value));
database->close();
- EXPECT_TRUE(database->open(name, Database::ReadOnly));
+ EXPECT_TRUE(database->open(name, Database<string, value_type>::ReadOnly));
- Database::value_type new_val;
+ value_type new_value;
- EXPECT_FALSE(database->get(key, &new_val));
+ EXPECT_FALSE(database->get(key, &new_value));
}
+#undef UNPACK_TYPES
+
} // namespace caffe