From fb64a3427e2d79fd7cce046f661777594e4b35e0 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Wed, 9 Feb 2022 21:19:37 -0500 Subject: [PATCH 01/12] Clean up some of the files left after test runs --- db/blob/db_blob_basic_test.cc | 2 + db/c_test.c | 6 + db/column_family_test.cc | 2 + db/compact_files_test.cc | 298 ++++++++---------- db/compaction/compaction_job_test.cc | 7 + db/db_basic_test.cc | 1 + db/db_compaction_test.cc | 24 +- db/db_encryption_test.cc | 1 + db/db_sst_test.cc | 3 + db/db_test.cc | 4 + db/db_wal_test.cc | 1 + db/fault_injection_test.cc | 1 + db/listener_test.cc | 3 + db/options_file_test.cc | 1 + db/perf_context_test.cc | 11 +- db/periodic_work_scheduler_test.cc | 4 + db/prefix_test.cc | 43 +-- env/env_test.cc | 50 +-- logging/auto_roll_logger_test.cc | 162 ++++------ table/cuckoo/cuckoo_table_builder_test.cc | 6 + table/cuckoo/cuckoo_table_reader_test.cc | 6 + table/table_test.cc | 14 +- tools/reduce_levels_test.cc | 4 +- tools/trace_analyzer_test.cc | 2 +- utilities/backupable/backupable_db_test.cc | 6 + utilities/checkpoint/checkpoint_test.cc | 1 + utilities/memory/memory_test.cc | 18 +- .../string_append/stringappend_test.cc | 91 ++---- utilities/options/options_util_test.cc | 1 + utilities/transactions/transaction_test.h | 1 + .../write_prepared_transaction_test.cc | 1 + 31 files changed, 389 insertions(+), 386 deletions(-) diff --git a/db/blob/db_blob_basic_test.cc b/db/blob/db_blob_basic_test.cc index 7f027fe3fe9..8bb61141577 100644 --- a/db/blob/db_blob_basic_test.cc +++ b/db/blob/db_blob_basic_test.cc @@ -315,6 +315,7 @@ TEST_F(DBBlobBasicTest, MultiGetWithDirectIO) { ASSERT_OK(statuses[2]); ASSERT_EQ(values[2], second_blob); } + ASSERT_OK(options.env->DeleteFile(file_path)); } #endif // !ROCKSDB_LITE @@ -574,6 +575,7 @@ TEST_F(DBBlobBasicTest, GenerateIOTracing) { // Assuming blob files will have Append, Close and then Read operations. ASSERT_GT(blob_files_op_count, 2); } + ASSERT_OK(env_->DeleteFile(trace_file)); } #endif // !ROCKSDB_LITE diff --git a/db/c_test.c b/db/c_test.c index 1ee01e46daf..97415e6b870 100644 --- a/db/c_test.c +++ b/db/c_test.c @@ -590,6 +590,9 @@ int main(int argc, char** argv) { CheckGet(db, roptions, "foo", "hello"); rocksdb_backup_engine_close(be); + + rocksdb_destroy_db(options, dbbackupname, &err); + CheckNoError(err); } StartPhase("checkpoint"); @@ -717,6 +720,7 @@ int main(int argc, char** argv) { CheckNoError(err); rocksdb_delete(db, woptions, "sstk3", 5, &err); CheckNoError(err); + remove(sstfilename); } StartPhase("writebatch"); @@ -2964,6 +2968,8 @@ int main(int argc, char** argv) { StartPhase("cleanup"); rocksdb_close(db); + rocksdb_destroy_db(options, dbname, &err); + CheckNoError(err); rocksdb_options_destroy(options); rocksdb_block_based_options_destroy(table_options); rocksdb_readoptions_destroy(roptions); diff --git a/db/column_family_test.cc b/db/column_family_test.cc index c55eb129059..c470a05e10e 100644 --- a/db/column_family_test.cc +++ b/db/column_family_test.cc @@ -82,6 +82,7 @@ class ColumnFamilyTestBase : public testing::Test { } ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); Destroy(column_families); + EXPECT_OK(DestroyDB(dbname_, Options(db_options_, column_family_options_))); delete env_; } @@ -948,6 +949,7 @@ TEST_P(ColumnFamilyTest, IgnoreRecoveredLog) { } } } + ASSERT_OK(DestroyDir(env_, backup_logs)); } #ifndef ROCKSDB_LITE // TEST functions used are not supported diff --git a/db/compact_files_test.cc b/db/compact_files_test.cc index 4793adddf7c..370848f80b6 100644 --- a/db/compact_files_test.cc +++ b/db/compact_files_test.cc @@ -23,11 +23,31 @@ namespace ROCKSDB_NAMESPACE { class CompactFilesTest : public testing::Test { public: - CompactFilesTest() { + CompactFilesTest() : db_(nullptr) { env_ = Env::Default(); - db_name_ = test::PerThreadDBPath("compact_files_test"); + db_name_ = test::PerThreadDBPath(env_, "compact_files_test"); + options_.env = env_; + options_.create_if_missing = true; + EXPECT_OK(DestroyDB(db_name_, options_)); } + ~CompactFilesTest() { + CloseDB(); + EXPECT_OK(DestroyDB(db_name_, options_)); + } + + void OpenDB() { + ASSERT_OK(DB::Open(options_, db_name_, &db_)); + ASSERT_NE(db_, nullptr); + } + + void CloseDB() { + delete db_; + db_ = nullptr; + } + + Options options_; + DB* db_; std::string db_name_; Env* env_; }; @@ -62,25 +82,19 @@ class FlushedFileCollector : public EventListener { }; TEST_F(CompactFilesTest, L0ConflictsFiles) { - Options options; // to trigger compaction more easily const int kWriteBufferSize = 10000; const int kLevel0Trigger = 2; - options.create_if_missing = true; - options.compaction_style = kCompactionStyleLevel; + options_.compaction_style = kCompactionStyleLevel; // Small slowdown and stop trigger for experimental purpose. - options.level0_slowdown_writes_trigger = 20; - options.level0_stop_writes_trigger = 20; - options.level0_stop_writes_trigger = 20; - options.write_buffer_size = kWriteBufferSize; - options.level0_file_num_compaction_trigger = kLevel0Trigger; - options.compression = kNoCompression; - - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - assert(s.ok()); - assert(db); + options_.level0_slowdown_writes_trigger = 20; + options_.level0_stop_writes_trigger = 20; + options_.level0_stop_writes_trigger = 20; + options_.write_buffer_size = kWriteBufferSize; + options_.level0_file_num_compaction_trigger = kLevel0Trigger; + options_.compression = kNoCompression; + + OpenDB(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency({ {"CompactFilesImpl:0", "BackgroundCallCompaction:0"}, @@ -91,13 +105,13 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) { // create couple files // Background compaction starts and waits in BackgroundCallCompaction:0 for (int i = 0; i < kLevel0Trigger * 4; ++i) { - ASSERT_OK(db->Put(WriteOptions(), ToString(i), "")); - ASSERT_OK(db->Put(WriteOptions(), ToString(100 - i), "")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), "")); + ASSERT_OK(db_->Put(WriteOptions(), ToString(100 - i), "")); + ASSERT_OK(db_->Flush(FlushOptions())); } ROCKSDB_NAMESPACE::ColumnFamilyMetaData meta; - db->GetColumnFamilyMetaData(&meta); + db_->GetColumnFamilyMetaData(&meta); std::string file1; for (auto& file : meta.levels[0].files) { ASSERT_EQ(0, meta.levels[0].level); @@ -109,48 +123,41 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) { // The background compaction then notices that there is an L0 compaction // already in progress and doesn't do an L0 compaction // Once the background compaction finishes, the compact files finishes - ASSERT_OK(db->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), - {file1, file2}, 0)); + ASSERT_OK(db_->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), + {file1, file2}, 0)); break; } } ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); - delete db; } TEST_F(CompactFilesTest, MultipleLevel) { - Options options; - options.create_if_missing = true; - options.level_compaction_dynamic_level_bytes = true; - options.num_levels = 6; + options_.level_compaction_dynamic_level_bytes = true; + options_.num_levels = 6; // Add listener FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); + options_.listeners.emplace_back(collector); - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); - ASSERT_NE(db, nullptr); + OpenDB(); // create couple files in L0, L3, L4 and L5 for (int i = 5; i > 2; --i) { collector->ClearFlushedFiles(); - ASSERT_OK(db->Put(WriteOptions(), ToString(i), "")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), "")); + ASSERT_OK(db_->Flush(FlushOptions())); auto l0_files = collector->GetFlushedFiles(); - ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files, i)); + ASSERT_OK(db_->CompactFiles(CompactionOptions(), l0_files, i)); std::string prop; ASSERT_TRUE( - db->GetProperty("rocksdb.num-files-at-level" + ToString(i), &prop)); + db_->GetProperty("rocksdb.num-files-at-level" + ToString(i), &prop)); ASSERT_EQ("1", prop); } - ASSERT_OK(db->Put(WriteOptions(), ToString(0), "")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), ToString(0), "")); + ASSERT_OK(db_->Flush(FlushOptions())); ColumnFamilyMetaData meta; - db->GetColumnFamilyMetaData(&meta); + db_->GetColumnFamilyMetaData(&meta); // Compact files except the file in L3 std::vector files; for (int i = 0; i < 6; ++i) { @@ -168,9 +175,9 @@ TEST_F(CompactFilesTest, MultipleLevel) { std::thread thread([&] { TEST_SYNC_POINT("CompactFilesTest.MultipleLevel:0"); - ASSERT_OK(db->Put(WriteOptions(), "bar", "v2")); - ASSERT_OK(db->Put(WriteOptions(), "foo", "v2")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), "bar", "v2")); + ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2")); + ASSERT_OK(db_->Flush(FlushOptions())); TEST_SYNC_POINT("CompactFilesTest.MultipleLevel:1"); }); @@ -178,122 +185,100 @@ TEST_F(CompactFilesTest, MultipleLevel) { // here we have input file from level 5, so the output level has to be >= 5 for (int invalid_output_level = 0; invalid_output_level < 5; invalid_output_level++) { - s = db->CompactFiles(CompactionOptions(), files, invalid_output_level); + Status s = + db_->CompactFiles(CompactionOptions(), files, invalid_output_level); std::cout << s.ToString() << std::endl; ASSERT_TRUE(s.IsInvalidArgument()); } - ASSERT_OK(db->CompactFiles(CompactionOptions(), files, 5)); + ASSERT_OK(db_->CompactFiles(CompactionOptions(), files, 5)); SyncPoint::GetInstance()->DisableProcessing(); thread.join(); - - delete db; } TEST_F(CompactFilesTest, ObsoleteFiles) { - Options options; // to trigger compaction more easily const int kWriteBufferSize = 65536; - options.create_if_missing = true; // Disable RocksDB background compaction. - options.compaction_style = kCompactionStyleNone; - options.level0_slowdown_writes_trigger = (1 << 30); - options.level0_stop_writes_trigger = (1 << 30); - options.write_buffer_size = kWriteBufferSize; - options.max_write_buffer_number = 2; - options.compression = kNoCompression; + options_.compaction_style = kCompactionStyleNone; + options_.level0_slowdown_writes_trigger = (1 << 30); + options_.level0_stop_writes_trigger = (1 << 30); + options_.write_buffer_size = kWriteBufferSize; + options_.max_write_buffer_number = 2; + options_.compression = kNoCompression; // Add listener FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); + options_.listeners.emplace_back(collector); - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); - ASSERT_NE(db, nullptr); + OpenDB(); // create couple files for (int i = 1000; i < 2000; ++i) { - ASSERT_OK(db->Put(WriteOptions(), ToString(i), - std::string(kWriteBufferSize / 10, 'a' + (i % 26)))); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), + std::string(kWriteBufferSize / 10, 'a' + (i % 26)))); } auto l0_files = collector->GetFlushedFiles(); - ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files, 1)); - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForCompact()); + ASSERT_OK(db_->CompactFiles(CompactionOptions(), l0_files, 1)); + ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForCompact()); // verify all compaction input files are deleted for (auto fname : l0_files) { ASSERT_EQ(Status::NotFound(), env_->FileExists(fname)); } - delete db; } TEST_F(CompactFilesTest, NotCutOutputOnLevel0) { - Options options; - options.create_if_missing = true; // Disable RocksDB background compaction. - options.compaction_style = kCompactionStyleNone; - options.level0_slowdown_writes_trigger = 1000; - options.level0_stop_writes_trigger = 1000; - options.write_buffer_size = 65536; - options.max_write_buffer_number = 2; - options.compression = kNoCompression; - options.max_compaction_bytes = 5000; + options_.compaction_style = kCompactionStyleNone; + options_.level0_slowdown_writes_trigger = 1000; + options_.level0_stop_writes_trigger = 1000; + options_.write_buffer_size = 65536; + options_.max_write_buffer_number = 2; + options_.compression = kNoCompression; + options_.max_compaction_bytes = 5000; // Add listener FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); + options_.listeners.emplace_back(collector); - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - assert(s.ok()); - assert(db); + OpenDB(); // create couple files for (int i = 0; i < 500; ++i) { - ASSERT_OK(db->Put(WriteOptions(), ToString(i), - std::string(1000, 'a' + (i % 26)))); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), + std::string(1000, 'a' + (i % 26)))); } - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForFlushMemTable()); + ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForFlushMemTable()); auto l0_files_1 = collector->GetFlushedFiles(); collector->ClearFlushedFiles(); for (int i = 0; i < 500; ++i) { - ASSERT_OK(db->Put(WriteOptions(), ToString(i), - std::string(1000, 'a' + (i % 26)))); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), + std::string(1000, 'a' + (i % 26)))); } - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForFlushMemTable()); + ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForFlushMemTable()); auto l0_files_2 = collector->GetFlushedFiles(); - ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files_1, 0)); - ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files_2, 0)); - // no assertion failure - delete db; + ASSERT_OK(db_->CompactFiles(CompactionOptions(), l0_files_1, 0)); + ASSERT_OK(db_->CompactFiles(CompactionOptions(), l0_files_2, 0)); } TEST_F(CompactFilesTest, CapturingPendingFiles) { - Options options; - options.create_if_missing = true; // Disable RocksDB background compaction. - options.compaction_style = kCompactionStyleNone; + options_.compaction_style = kCompactionStyleNone; // Always do full scans for obsolete files (needed to reproduce the issue). - options.delete_obsolete_files_period_micros = 0; + options_.delete_obsolete_files_period_micros = 0; // Add listener. FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); + options_.listeners.emplace_back(collector); - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); - assert(db); + OpenDB(); // Create 5 files. for (int i = 0; i < 5; ++i) { - ASSERT_OK(db->Put(WriteOptions(), "key" + ToString(i), "value")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), "key" + ToString(i), "value")); + ASSERT_OK(db_->Flush(FlushOptions())); } auto l0_files = collector->GetFlushedFiles(); @@ -307,25 +292,22 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) { // Start compacting files. ROCKSDB_NAMESPACE::port::Thread compaction_thread( - [&] { EXPECT_OK(db->CompactFiles(CompactionOptions(), l0_files, 1)); }); + [&] { EXPECT_OK(db_->CompactFiles(CompactionOptions(), l0_files, 1)); }); // In the meantime flush another file. TEST_SYNC_POINT("CompactFilesTest.CapturingPendingFiles:0"); - ASSERT_OK(db->Put(WriteOptions(), "key5", "value")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), "key5", "value")); + ASSERT_OK(db_->Flush(FlushOptions())); TEST_SYNC_POINT("CompactFilesTest.CapturingPendingFiles:1"); compaction_thread.join(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); - delete db; + CloseDB(); // Make sure we can reopen the DB. - s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); - assert(db); - delete db; + OpenDB(); } TEST_F(CompactFilesTest, CompactionFilterWithGetSv) { @@ -355,41 +337,32 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) { std::shared_ptr cf(new FilterWithGet()); - Options options; - options.create_if_missing = true; - options.compaction_filter = cf.get(); - - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); + options_.compaction_filter = cf.get(); - cf->SetDB(db); + OpenDB(); + cf->SetDB(db_); // Write one L0 file - ASSERT_OK(db->Put(WriteOptions(), "K1", "V1")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), "K1", "V1")); + ASSERT_OK(db_->Flush(FlushOptions())); // Compact all L0 files using CompactFiles ROCKSDB_NAMESPACE::ColumnFamilyMetaData meta; - db->GetColumnFamilyMetaData(&meta); + db_->GetColumnFamilyMetaData(&meta); for (auto& file : meta.levels[0].files) { std::string fname = file.db_path + "/" + file.name; ASSERT_OK( - db->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), {fname}, 0)); + db_->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), {fname}, 0)); } - - - delete db; } TEST_F(CompactFilesTest, SentinelCompressionType) { if (!Zlib_Supported()) { - fprintf(stderr, "zlib compression not supported, skip this test\n"); + ROCKSDB_GTEST_SKIP("zlib compression not supported, skip this test"); return; } if (!Snappy_Supported()) { - fprintf(stderr, "snappy compression not supported, skip this test\n"); + ROCKSDB_GTEST_SKIP("snappy compression not supported, skip this test"); return; } // Check that passing `CompressionType::kDisableCompressionOption` to @@ -398,21 +371,18 @@ TEST_F(CompactFilesTest, SentinelCompressionType) { {CompactionStyle::kCompactionStyleLevel, CompactionStyle::kCompactionStyleUniversal, CompactionStyle::kCompactionStyleNone}) { - DestroyDB(db_name_, Options()); - Options options; - options.compaction_style = compaction_style; + ASSERT_OK(DestroyDB(db_name_, options_)); + options_.compaction_style = compaction_style; // L0: Snappy, L1: ZSTD, L2: Snappy - options.compression_per_level = {CompressionType::kSnappyCompression, - CompressionType::kZlibCompression, - CompressionType::kSnappyCompression}; - options.create_if_missing = true; + options_.compression_per_level = {CompressionType::kSnappyCompression, + CompressionType::kZlibCompression, + CompressionType::kSnappyCompression}; FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); - DB* db = nullptr; - ASSERT_OK(DB::Open(options, db_name_, &db)); + options_.listeners.emplace_back(collector); - ASSERT_OK(db->Put(WriteOptions(), "key", "val")); - ASSERT_OK(db->Flush(FlushOptions())); + OpenDB(); + ASSERT_OK(db_->Put(WriteOptions(), "key", "val")); + ASSERT_OK(db_->Flush(FlushOptions())); auto l0_files = collector->GetFlushedFiles(); ASSERT_EQ(1, l0_files.size()); @@ -420,62 +390,54 @@ TEST_F(CompactFilesTest, SentinelCompressionType) { // L0->L1 compaction, so output should be ZSTD-compressed CompactionOptions compaction_opts; compaction_opts.compression = CompressionType::kDisableCompressionOption; - ASSERT_OK(db->CompactFiles(compaction_opts, l0_files, 1)); + ASSERT_OK(db_->CompactFiles(compaction_opts, l0_files, 1)); ROCKSDB_NAMESPACE::TablePropertiesCollection all_tables_props; - ASSERT_OK(db->GetPropertiesOfAllTables(&all_tables_props)); + ASSERT_OK(db_->GetPropertiesOfAllTables(&all_tables_props)); for (const auto& name_and_table_props : all_tables_props) { ASSERT_EQ(CompressionTypeToString(CompressionType::kZlibCompression), name_and_table_props.second->compression_name); } - delete db; + CloseDB(); } } TEST_F(CompactFilesTest, GetCompactionJobInfo) { - Options options; - options.create_if_missing = true; // Disable RocksDB background compaction. - options.compaction_style = kCompactionStyleNone; - options.level0_slowdown_writes_trigger = 1000; - options.level0_stop_writes_trigger = 1000; - options.write_buffer_size = 65536; - options.max_write_buffer_number = 2; - options.compression = kNoCompression; - options.max_compaction_bytes = 5000; + options_.compaction_style = kCompactionStyleNone; + options_.level0_slowdown_writes_trigger = 1000; + options_.level0_stop_writes_trigger = 1000; + options_.write_buffer_size = 65536; + options_.max_write_buffer_number = 2; + options_.compression = kNoCompression; + options_.max_compaction_bytes = 5000; // Add listener FlushedFileCollector* collector = new FlushedFileCollector(); - options.listeners.emplace_back(collector); + options_.listeners.emplace_back(collector); - DB* db = nullptr; - DestroyDB(db_name_, options); - Status s = DB::Open(options, db_name_, &db); - ASSERT_OK(s); - assert(db); + OpenDB(); // create couple files for (int i = 0; i < 500; ++i) { - ASSERT_OK(db->Put(WriteOptions(), ToString(i), - std::string(1000, 'a' + (i % 26)))); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), + std::string(1000, 'a' + (i % 26)))); } - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForFlushMemTable()); + ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForFlushMemTable()); auto l0_files_1 = collector->GetFlushedFiles(); CompactionOptions co; co.compression = CompressionType::kLZ4Compression; CompactionJobInfo compaction_job_info{}; ASSERT_OK( - db->CompactFiles(co, l0_files_1, 0, -1, nullptr, &compaction_job_info)); + db_->CompactFiles(co, l0_files_1, 0, -1, nullptr, &compaction_job_info)); ASSERT_EQ(compaction_job_info.base_input_level, 0); - ASSERT_EQ(compaction_job_info.cf_id, db->DefaultColumnFamily()->GetID()); - ASSERT_EQ(compaction_job_info.cf_name, db->DefaultColumnFamily()->GetName()); + ASSERT_EQ(compaction_job_info.cf_id, db_->DefaultColumnFamily()->GetID()); + ASSERT_EQ(compaction_job_info.cf_name, db_->DefaultColumnFamily()->GetName()); ASSERT_EQ(compaction_job_info.compaction_reason, CompactionReason::kManualCompaction); ASSERT_EQ(compaction_job_info.compression, CompressionType::kLZ4Compression); ASSERT_EQ(compaction_job_info.output_level, 0); ASSERT_OK(compaction_job_info.status); - // no assertion failure - delete db; } } // namespace ROCKSDB_NAMESPACE diff --git a/db/compaction/compaction_job_test.cc b/db/compaction/compaction_job_test.cc index bd688ca3f22..fc2c588bd68 100644 --- a/db/compaction/compaction_job_test.cc +++ b/db/compaction/compaction_job_test.cc @@ -20,6 +20,7 @@ #include "db/error_handler.h" #include "db/version_set.h" #include "file/writable_file_writer.h" +#include "options/options_helper.h" #include "rocksdb/cache.h" #include "rocksdb/convenience.h" #include "rocksdb/db.h" @@ -98,6 +99,12 @@ class CompactionJobTestBase : public testing::Test { fs_ = env_->GetFileSystem(); } + ~CompactionJobTestBase() { + Options options(BuildDBOptions(db_options_, mutable_db_options_), + ColumnFamilyOptions()); + EXPECT_OK(DestroyDB(dbname_, options)); + } + void SetUp() override { EXPECT_OK(env_->CreateDirIfMissing(dbname_)); db_options_.env = env_; diff --git a/db/db_basic_test.cc b/db/db_basic_test.cc index f27532c1128..60f3d2f139a 100644 --- a/db/db_basic_test.cc +++ b/db/db_basic_test.cc @@ -1147,6 +1147,7 @@ TEST_F(DBBasicTest, DBClose) { ASSERT_EQ(env->GetCloseCount(), 2); options.info_log.reset(); ASSERT_EQ(env->GetCloseCount(), 3); + ASSERT_OK(DestroyDB(dbname, options)); } TEST_F(DBBasicTest, DBCloseFlushError) { diff --git a/db/db_compaction_test.cc b/db/db_compaction_test.cc index d6616ab0973..4de5d8c02d8 100644 --- a/db/db_compaction_test.cc +++ b/db/db_compaction_test.cc @@ -5369,6 +5369,7 @@ TEST_P(DBCompactionTestWithParam, FixFileIngestionCompactionDeadlock) { ingestion_thr.join(); ASSERT_OK(dbfull()->TEST_WaitForCompact()); Close(); + ASSERT_OK(DestroyDir(env_, sst_files_dir)); } TEST_F(DBCompactionTest, ConsistencyFailTest) { @@ -5448,19 +5449,22 @@ TEST_F(DBCompactionTest, ConsistencyFailTest2) { void IngestOneKeyValue(DBImpl* db, const std::string& key, const std::string& value, const Options& options) { - ExternalSstFileInfo info; std::string f = test::PerThreadDBPath("sst_file" + key); - EnvOptions env; - ROCKSDB_NAMESPACE::SstFileWriter writer(env, options); - auto s = writer.Open(f); - ASSERT_OK(s); - // ASSERT_OK(writer.Put(Key(), "")); - ASSERT_OK(writer.Put(key, value)); + { + ExternalSstFileInfo info; + EnvOptions env; + ROCKSDB_NAMESPACE::SstFileWriter writer(env, options); + auto s = writer.Open(f); + ASSERT_OK(s); + // ASSERT_OK(writer.Put(Key(), "")); + ASSERT_OK(writer.Put(key, value)); - ASSERT_OK(writer.Finish(&info)); - IngestExternalFileOptions ingest_opt; + ASSERT_OK(writer.Finish(&info)); + IngestExternalFileOptions ingest_opt; - ASSERT_OK(db->IngestExternalFile({info.file_path}, ingest_opt)); + ASSERT_OK(db->IngestExternalFile({info.file_path}, ingest_opt)); + } + ASSERT_OK(db->GetEnv()->DeleteFile(f)); } TEST_P(DBCompactionTestWithParam, diff --git a/db/db_encryption_test.cc b/db/db_encryption_test.cc index b7000dd7a2a..0ccad4e5325 100644 --- a/db/db_encryption_test.cc +++ b/db/db_encryption_test.cc @@ -117,6 +117,7 @@ TEST_F(DBEncryptionTest, ReadEmptyFile) { ASSERT_OK(status); ASSERT_TRUE(data.empty()); + ASSERT_OK(defaultEnv->DeleteFile(filePath)); } #endif // ROCKSDB_LITE diff --git a/db/db_sst_test.cc b/db/db_sst_test.cc index b036e1ef969..8575d17de9a 100644 --- a/db/db_sst_test.cc +++ b/db/db_sst_test.cc @@ -715,6 +715,9 @@ TEST_P(DBSSTTestRateLimit, RateLimitedDelete) { 0, options.statistics->getAndResetTickerCount(FILES_DELETED_IMMEDIATELY)); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); + if (different_wal_dir) { + ASSERT_OK(DestroyDir(options.env, alternative_wal_dir_)); + } } INSTANTIATE_TEST_CASE_P(RateLimitedDelete, DBSSTTestRateLimit, diff --git a/db/db_test.cc b/db/db_test.cc index 8f66091413a..8b33fb7f65a 100644 --- a/db/db_test.cc +++ b/db/db_test.cc @@ -2232,6 +2232,7 @@ TEST_F(DBTest, DBOpen_Options) { delete db; db = nullptr; + ASSERT_OK(DestroyDB(dbname, options)); } TEST_F(DBTest, DBOpen_Change_NumLevels) { @@ -2288,6 +2289,8 @@ TEST_F(DBTest, DestroyDBMetaDatabase) { ASSERT_TRUE(!(DB::Open(options, dbname, &db)).ok()); ASSERT_TRUE(!(DB::Open(options, metadbname, &db)).ok()); ASSERT_TRUE(!(DB::Open(options, metametadbname, &db)).ok()); + ASSERT_OK( + DestroyDir(env_, dbname)); // The meta dbs leave stuff around. Clean up } #ifndef ROCKSDB_LITE @@ -2439,6 +2442,7 @@ TEST_F(DBTest, SnapshotFiles) { ASSERT_EQ(info.file_number, manifest_number); } } + ASSERT_OK(DestroyDir(env_, snapdir)); } while (ChangeCompactOptions()); } diff --git a/db/db_wal_test.cc b/db/db_wal_test.cc index b24a5c633ed..1322e00263c 100644 --- a/db/db_wal_test.cc +++ b/db/db_wal_test.cc @@ -743,6 +743,7 @@ TEST_F(DBWALTest, IgnoreRecoveredLog) { ASSERT_NOK(s); Destroy(options); } while (ChangeWalOptions()); + ASSERT_OK(DestroyDir(env_, backup_logs)); } TEST_F(DBWALTest, RecoveryWithEmptyLog) { diff --git a/db/fault_injection_test.cc b/db/fault_injection_test.cc index de675e69120..c4cae0d7333 100644 --- a/db/fault_injection_test.cc +++ b/db/fault_injection_test.cc @@ -614,6 +614,7 @@ TEST_P(FaultInjectionTest, NoDuplicateTrailingEntries) { // Verify that only one version edit exists in the file. ASSERT_EQ(1, count); } + ASSERT_OK(fault_fs->DeleteFile(file_name, IOOptions(), nullptr)); } INSTANTIATE_TEST_CASE_P( diff --git a/db/listener_test.cc b/db/listener_test.cc index fd4470e3b6f..76989f7ee13 100644 --- a/db/listener_test.cc +++ b/db/listener_test.cc @@ -476,6 +476,9 @@ TEST_F(EventListenerTest, MultiDBMultiListeners) { for (auto db : dbs) { delete db; } + for (int d = 0; d < kNumDBs; ++d) { + ASSERT_OK(DestroyDB(dbname_ + ToString(d), options)); + } } TEST_F(EventListenerTest, DisableBGCompaction) { diff --git a/db/options_file_test.cc b/db/options_file_test.cc index 3ff7e0952b4..d7681bcbe96 100644 --- a/db/options_file_test.cc +++ b/db/options_file_test.cc @@ -78,6 +78,7 @@ TEST_F(OptionsFileTest, NumberOfOptionsFiles) { VerifyOptionsFileName(db, filename_history); delete db; } + ASSERT_OK(DestroyDB(dbname_, opt)); } TEST_F(OptionsFileTest, OptionsFileName) { diff --git a/db/perf_context_test.cc b/db/perf_context_test.cc index 908e684f73e..261e1247846 100644 --- a/db/perf_context_test.cc +++ b/db/perf_context_test.cc @@ -66,10 +66,14 @@ std::shared_ptr OpenDb(bool read_only = false) { return std::shared_ptr(db); } -class PerfContextTest : public testing::Test {}; +class PerfContextTest : public testing::Test { + public: + PerfContextTest() { EXPECT_OK(DestroyDB(kDbName, Options())); } + + ~PerfContextTest() { EXPECT_OK(DestroyDB(kDbName, Options())); } +}; TEST_F(PerfContextTest, SeekIntoDeletion) { - DestroyDB(kDbName, Options()); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -518,7 +522,6 @@ TEST_F(PerfContextTest, KeyComparisonCount) { // starts to become linear to the input size. TEST_F(PerfContextTest, SeekKeyComparison) { - DestroyDB(kDbName, Options()); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -652,7 +655,6 @@ TEST_F(PerfContextTest, ToString) { } TEST_F(PerfContextTest, MergeOperatorTime) { - DestroyDB(kDbName, Options()); DB* db; Options options; options.create_if_missing = true; @@ -833,7 +835,6 @@ TEST_F(PerfContextTest, CPUTimer) { return; } - DestroyDB(kDbName, Options()); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; diff --git a/db/periodic_work_scheduler_test.cc b/db/periodic_work_scheduler_test.cc index acddad9f8c8..dcec3fda17d 100644 --- a/db/periodic_work_scheduler_test.cc +++ b/db/periodic_work_scheduler_test.cc @@ -192,6 +192,9 @@ TEST_F(PeriodicWorkSchedulerTest, MultiInstances) { ASSERT_OK(dbs[i]->Close()); delete dbs[i]; } + for (int i = 0; i < kInstanceNum; i++) { + ASSERT_OK(DestroyDB(test::PerThreadDBPath(std::to_string(i)), options)); + } } TEST_F(PeriodicWorkSchedulerTest, MultiEnv) { @@ -225,6 +228,7 @@ TEST_F(PeriodicWorkSchedulerTest, MultiEnv) { ASSERT_OK(db->Close()); delete db; Close(); + ASSERT_OK(DestroyDB(dbname, options2)); } #endif // !ROCKSDB_LITE } // namespace ROCKSDB_NAMESPACE diff --git a/db/prefix_test.cc b/db/prefix_test.cc index 37673eb8c8a..90268d2c635 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -54,9 +54,6 @@ DEFINE_int32(memtable_huge_page_size, 2 * 1024 * 1024, ""); DEFINE_int32(value_size, 40, ""); DEFINE_bool(enable_print, false, "Print options generated to console."); -// Path to the database on file system -const std::string kDbName = - ROCKSDB_NAMESPACE::test::PerThreadDBPath("prefix_test"); namespace ROCKSDB_NAMESPACE { @@ -219,6 +216,8 @@ class SamePrefixTransform : public SliceTransform { class PrefixTest : public testing::Test { public: + // Path to the database on file system + std::shared_ptr OpenDb() { DB* db; @@ -239,7 +238,7 @@ class PrefixTest : public testing::Test { options.table_factory.reset(NewBlockBasedTableFactory(bbto)); options.allow_concurrent_memtable_write = false; - Status s = DB::Open(options, kDbName, &db); + Status s = DB::Open(options, dbname_, &db); EXPECT_OK(s); return std::shared_ptr(db); } @@ -279,8 +278,16 @@ class PrefixTest : public testing::Test { PrefixTest() : option_config_(kBegin) { options.comparator = new TestKeyComparator(); + dbname_ = ROCKSDB_NAMESPACE::test::PerThreadDBPath("prefix_test"); + EXPECT_OK(DestroyDB(dbname_, options)); + EXPECT_OK(DestroyDB(dbname_, options)); + } + ~PrefixTest() override { + EXPECT_OK(DestroyDB(dbname_, options)); + delete options.comparator; } - ~PrefixTest() override { delete options.comparator; } + + std::string dbname_; protected: enum OptionConfig { @@ -295,7 +302,7 @@ class PrefixTest : public testing::Test { Options options; }; -TEST(SamePrefixTest, InDomainTest) { +TEST_F(PrefixTest, InDomainTest) { DB* db; Options options; options.create_if_missing = true; @@ -307,8 +314,8 @@ TEST(SamePrefixTest, InDomainTest) { WriteOptions write_options; ReadOptions read_options; { - ASSERT_OK(DestroyDB(kDbName, Options())); - ASSERT_OK(DB::Open(options, kDbName, &db)); + ASSERT_OK(DestroyDB(dbname_, Options())); + ASSERT_OK(DB::Open(options, dbname_, &db)); ASSERT_OK(db->Put(write_options, "HHKB pro2", "Mar 24, 2006")); ASSERT_OK(db->Put(write_options, "HHKB pro2 Type-S", "June 29, 2011")); ASSERT_OK(db->Put(write_options, "Realforce 87u", "idk")); @@ -324,11 +331,11 @@ TEST(SamePrefixTest, InDomainTest) { delete db_iter; delete db; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); } { - ASSERT_OK(DB::Open(options, kDbName, &db)); + ASSERT_OK(DB::Open(options, dbname_, &db)); ASSERT_OK(db->Put(write_options, "pikachu", "1")); ASSERT_OK(db->Put(write_options, "Meowth", "1")); ASSERT_OK(db->Put(write_options, "Mewtwo", "idk")); @@ -341,7 +348,7 @@ TEST(SamePrefixTest, InDomainTest) { ASSERT_OK(db_iter->status()); delete db_iter; delete db; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); } } @@ -352,7 +359,7 @@ TEST_F(PrefixTest, TestResult) { std::cout << "*** Mem table: " << options.memtable_factory->Name() << " number of buckets: " << num_buckets << std::endl; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -529,7 +536,7 @@ TEST_F(PrefixTest, PrefixValid) { while (NextOptions(num_buckets)) { std::cout << "*** Mem table: " << options.memtable_factory->Name() << " number of buckets: " << num_buckets << std::endl; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -582,7 +589,7 @@ TEST_F(PrefixTest, DynamicPrefixIterator) { while (NextOptions(FLAGS_bucket_count)) { std::cout << "*** Mem table: " << options.memtable_factory->Name() << std::endl; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -689,7 +696,7 @@ TEST_F(PrefixTest, PrefixSeekModePrev) { for (size_t m = 1; m < 100; m++) { std::cout << "[" + std::to_string(m) + "]" + "*** Mem table: " << options.memtable_factory->Name() << std::endl; - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -806,7 +813,7 @@ TEST_F(PrefixTest, PrefixSeekModePrev2) { options.memtable_factory.reset(new SkipListFactory); options.write_buffer_size = 1024 * 1024; std::string v13("v13"); - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -842,7 +849,7 @@ TEST_F(PrefixTest, PrefixSeekModePrev3) { Slice upper_bound = TestKeyToSlice(s, upper_bound_key); { - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; @@ -864,7 +871,7 @@ TEST_F(PrefixTest, PrefixSeekModePrev3) { ASSERT_EQ(iter->value(), v14); } { - ASSERT_OK(DestroyDB(kDbName, Options())); + ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; ReadOptions read_options; diff --git a/env/env_test.cc b/env/env_test.cc index 7333df580cc..5c9e79d4b79 100644 --- a/env/env_test.cc +++ b/env/env_test.cc @@ -109,11 +109,18 @@ class EnvPosixTest : public testing::Test { public: Env* env_; bool direct_io_; - EnvPosixTest() : env_(Env::Default()), direct_io_(false) {} + std::string fname_; + + EnvPosixTest() : env_(Env::Default()), direct_io_(false) { + fname_ = test::PerThreadDBPath(env_, "testfile"); + } ~EnvPosixTest() { SyncPoint::GetInstance()->DisableProcessing(); SyncPoint::GetInstance()->LoadDependency({}); SyncPoint::GetInstance()->ClearAllCallBacks(); + if (env_->FileExists(fname_).ok()) { + EXPECT_OK(env_->DeleteFile(fname_)); + } } }; @@ -312,11 +319,10 @@ TEST_F(EnvPosixTest, LowerThreadPoolCpuPriority) { TEST_F(EnvPosixTest, MemoryMappedFileBuffer) { const int kFileBytes = 1 << 15; // 32 KB std::string expected_data; - std::string fname = test::PerThreadDBPath(env_, "testfile"); { std::unique_ptr wfile; const EnvOptions soptions; - ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); Random rnd(301); expected_data = rnd.RandomString(kFileBytes); @@ -324,7 +330,7 @@ TEST_F(EnvPosixTest, MemoryMappedFileBuffer) { } std::unique_ptr mmap_buffer; - Status status = env_->NewMemoryMappedFileBuffer(fname, &mmap_buffer); + Status status = env_->NewMemoryMappedFileBuffer(fname_, &mmap_buffer); // it should be supported at least on linux #if !defined(OS_LINUX) if (status.IsNotSupported()) { @@ -1219,7 +1225,6 @@ TEST_P(EnvPosixTestWithParam, DISABLED_RandomAccessUniqueIDDeletes) { TEST_P(EnvPosixTestWithParam, MultiRead) { EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = direct_io_; - std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kSectorSize = 4096; const size_t kNumSectors = 8; @@ -1233,7 +1238,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) { soptions.use_direct_writes = false; } #endif - ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); for (size_t i = 0; i < kNumSectors; ++i) { auto data = NewAligned(kSectorSize * 8, static_cast(i + 1)); Slice slice(data.get(), kSectorSize); @@ -1278,7 +1283,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); ASSERT_OK(file->MultiRead(reqs.data(), reqs.size())); for (size_t i = 0; i < reqs.size(); ++i) { auto buf = NewAligned(kSectorSize * 8, static_cast(i * 2 + 1)); @@ -1294,7 +1299,6 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // direct I/O case. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; - std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kTotalSize = 81920; Random rnd(301); @@ -1303,7 +1307,7 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // Create file. { std::unique_ptr wfile; - ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); ASSERT_OK(wfile->Append(expected_data)); ASSERT_OK(wfile->Close()); } @@ -1367,7 +1371,7 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); ASSERT_OK(file->MultiRead(reqs.data(), reqs.size())); // Validate results @@ -1421,14 +1425,13 @@ TEST_F(EnvPosixTest, MultiReadIOUringError) { // In this test we don't do aligned read, so we can't do direct I/O. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; - std::string fname = test::PerThreadDBPath(env_, "testfile"); std::vector scratches; std::vector reqs; - GenerateFilesAndRequest(env_, fname, &reqs, &scratches); + GenerateFilesAndRequest(env_, fname_, &reqs, &scratches); // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); bool io_uring_wait_cqe_called = false; SyncPoint::GetInstance()->SetCallBack( @@ -1457,14 +1460,13 @@ TEST_F(EnvPosixTest, MultiReadIOUringError2) { // In this test we don't do aligned read, so we can't do direct I/O. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; - std::string fname = test::PerThreadDBPath(env_, "testfile"); std::vector scratches; std::vector reqs; - GenerateFilesAndRequest(env_, fname, &reqs, &scratches); + GenerateFilesAndRequest(env_, fname_, &reqs, &scratches); // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); bool io_uring_submit_and_wait_called = false; SyncPoint::GetInstance()->SetCallBack( @@ -1505,7 +1507,6 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing(); EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = direct_io_; - std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kSectorSize = 512; auto data = NewAligned(kSectorSize, 0); @@ -1519,7 +1520,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_writes = false; } #endif - ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); ASSERT_OK(wfile->Append(slice)); ASSERT_OK(wfile->InvalidateCache(0, 0)); ASSERT_OK(wfile->Close()); @@ -1535,7 +1536,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); ASSERT_OK(file->Read(0, kSectorSize, &result, scratch.get())); ASSERT_EQ(memcmp(scratch.get(), data.get(), kSectorSize), 0); ASSERT_OK(file->InvalidateCache(0, 11)); @@ -1552,7 +1553,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewSequentialFile(fname, &file, soptions)); + ASSERT_OK(env_->NewSequentialFile(fname_, &file, soptions)); if (file->use_direct_io()) { ASSERT_OK(file->PositionedRead(0, kSectorSize, &result, scratch.get())); } else { @@ -1562,8 +1563,6 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { ASSERT_OK(file->InvalidateCache(0, 11)); ASSERT_OK(file->InvalidateCache(0, 0)); } - // Delete the file - ASSERT_OK(env_->DeleteFile(fname)); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearTrace(); } #endif // not TRAVIS @@ -1786,6 +1785,11 @@ TEST_P(EnvPosixTestWithParam, ConsistentChildrenAttributes) { ASSERT_EQ(size, file_attrs_iter->size_bytes); } ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearTrace(); + for (int i = 0; i < kNumChildren; ++i) { + const std::string path = test_base_dir + "/testfile_" + std::to_string(i); + ASSERT_OK(env_->DeleteFile(path)); + } + ASSERT_OK(env_->DeleteDir(test_base_dir)); } // Test that all WritableFileWrapper forwards all calls to WritableFile. @@ -2378,6 +2382,7 @@ TEST_F(EnvTest, IsDirectory) { } ASSERT_OK(Env::Default()->IsDirectory(test_file_path, &is_dir)); ASSERT_FALSE(is_dir); + ASSERT_OK(DestroyDir(Env::Default(), test_directory_)); } TEST_F(EnvTest, EnvWriteVerificationTest) { @@ -2400,6 +2405,7 @@ TEST_F(EnvTest, EnvWriteVerificationTest) { v_info.checksum = Slice(checksum); s = file->Append(Slice(test_data), v_info); ASSERT_OK(s); + ASSERT_OK(DestroyDir(Env::Default(), test_directory_)); } class CreateEnvTest : public testing::Test { diff --git a/logging/auto_roll_logger_test.cc b/logging/auto_roll_logger_test.cc index 19e7ea43f54..a610d246b87 100644 --- a/logging/auto_roll_logger_test.cc +++ b/logging/auto_roll_logger_test.cc @@ -49,19 +49,18 @@ void LogMessage(const InfoLogLevel log_level, Logger* logger, class AutoRollLoggerTest : public testing::Test { public: - static void InitTestDb() { -#ifdef OS_WIN - // Replace all slashes in the path so windows CompSpec does not - // become confused - std::string testDir(kTestDir); - std::replace_if(testDir.begin(), testDir.end(), - [](char ch) { return ch == '/'; }, '\\'); - std::string deleteCmd = "if exist " + testDir + " rd /s /q " + testDir; -#else - std::string deleteCmd = "rm -rf " + kTestDir; -#endif - ASSERT_TRUE(system(deleteCmd.c_str()) == 0); - ASSERT_OK(Env::Default()->CreateDir(kTestDir)); + AutoRollLoggerTest() { + env_ = Env::Default(); + test_dir_ = test::PerThreadDBPath(env_, "db_log_test"); + log_file_ = test_dir_ + "/LOG"; + RecreateLogDir(); + } + + ~AutoRollLoggerTest() { EXPECT_OK(DestroyDir(env_, test_dir_)); } + + void RecreateLogDir() { + EXPECT_OK(DestroyDir(env_, test_dir_)); + EXPECT_OK(env_->CreateDir(test_dir_)); } void RollLogFileBySizeTest(AutoRollLogger* logger, size_t log_max_size, @@ -70,11 +69,11 @@ class AutoRollLoggerTest : public testing::Test { const std::shared_ptr& sc, AutoRollLogger* logger, size_t time, const std::string& log_message); - // return list of files under kTestDir that contains "LOG" + // return list of files under test_dir_ that contains "LOG" std::vector GetLogFiles() { std::vector ret; std::vector files; - Status s = default_env->GetChildren(kTestDir, &files); + Status s = env_->GetChildren(test_dir_, &files); // Should call ASSERT_OK() here but it doesn't compile. It's not // worth the time figuring out why. EXPECT_TRUE(s.ok()); @@ -86,10 +85,10 @@ class AutoRollLoggerTest : public testing::Test { return ret; } - // Delete all log files under kTestDir + // Delete all log files under test_dir_ void CleanupLogFiles() { for (const std::string& f : GetLogFiles()) { - ASSERT_OK(default_env->DeleteFile(kTestDir + "/" + f)); + ASSERT_OK(env_->DeleteFile(test_dir_ + "/" + f)); } } @@ -107,18 +106,13 @@ class AutoRollLoggerTest : public testing::Test { } static const std::string kSampleMessage; - static const std::string kTestDir; - static const std::string kLogFile; - static Env* default_env; + std::string test_dir_; + std::string log_file_; + Env* env_; }; const std::string AutoRollLoggerTest::kSampleMessage( "this is the message to be written to the log file!!"); -const std::string AutoRollLoggerTest::kTestDir( - test::PerThreadDBPath("db_log_test")); -const std::string AutoRollLoggerTest::kLogFile( - test::PerThreadDBPath("db_log_test") + "/LOG"); -Env* AutoRollLoggerTest::default_env = Env::Default(); void AutoRollLoggerTest::RollLogFileBySizeTest(AutoRollLogger* logger, size_t log_max_size, @@ -157,7 +151,7 @@ void AutoRollLoggerTest::RollLogFileByTimeTest( uint64_t actual_ctime; uint64_t total_log_size; - EXPECT_OK(fs->GetFileSize(kLogFile, IOOptions(), &total_log_size, nullptr)); + EXPECT_OK(fs->GetFileSize(log_file_, IOOptions(), &total_log_size, nullptr)); expected_ctime = logger->TEST_ctime(); logger->SetCallNowMicrosEveryNRecords(0); @@ -189,12 +183,11 @@ void AutoRollLoggerTest::RollLogFileByTimeTest( } TEST_F(AutoRollLoggerTest, RollLogFileBySize) { - InitTestDb(); size_t log_max_size = 1024 * 5; size_t keep_log_file_num = 10; AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), - kTestDir, "", log_max_size, 0, keep_log_file_num); + test_dir_, "", log_max_size, 0, keep_log_file_num); RollLogFileBySizeTest(&logger, log_max_size, kSampleMessage + ":RollLogFileBySize"); @@ -208,24 +201,22 @@ TEST_F(AutoRollLoggerTest, RollLogFileByTime) { size_t log_size = 1024 * 5; size_t keep_log_file_num = 10; - InitTestDb(); // -- Test the existence of file during the server restart. - ASSERT_EQ(Status::NotFound(), default_env->FileExists(kLogFile)); - AutoRollLogger logger(default_env->GetFileSystem(), nsc, kTestDir, "", - log_size, time, keep_log_file_num); - ASSERT_OK(default_env->FileExists(kLogFile)); + ASSERT_EQ(Status::NotFound(), env_->FileExists(log_file_)); + AutoRollLogger logger(env_->GetFileSystem(), nsc, test_dir_, "", log_size, + time, keep_log_file_num); + ASSERT_OK(env_->FileExists(log_file_)); - RollLogFileByTimeTest(default_env->GetFileSystem(), nsc, &logger, time, + RollLogFileByTimeTest(env_->GetFileSystem(), nsc, &logger, time, kSampleMessage + ":RollLogFileByTime"); } TEST_F(AutoRollLoggerTest, SetInfoLogLevel) { - InitTestDb(); Options options; options.info_log_level = InfoLogLevel::FATAL_LEVEL; options.max_log_file_size = 1024; std::shared_ptr logger; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); auto* auto_roll_logger = dynamic_cast(logger.get()); ASSERT_NE(nullptr, auto_roll_logger); ASSERT_EQ(InfoLogLevel::FATAL_LEVEL, auto_roll_logger->GetInfoLogLevel()); @@ -241,7 +232,6 @@ TEST_F(AutoRollLoggerTest, SetInfoLogLevel) { TEST_F(AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size) { // If only 'log_max_size' options is specified, then every time // when rocksdb is restarted, a new empty log file will be created. - InitTestDb(); // WORKAROUND: // avoid complier's complaint of "comparison between signed // and unsigned integer expressions" because literal 0 is @@ -252,7 +242,7 @@ TEST_F(AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size) { AutoRollLogger* logger = new AutoRollLogger(FileSystem::Default(), SystemClock::Default(), - kTestDir, "", log_size, 0, keep_log_file_num); + test_dir_, "", log_size, 0, keep_log_file_num); LogMessage(logger, kSampleMessage.c_str()); ASSERT_GT(logger->GetLogFileSize(), kZero); @@ -260,7 +250,7 @@ TEST_F(AutoRollLoggerTest, OpenLogFilesMultipleTimesWithOptionLog_max_size) { // reopens the log file and an empty log file will be created. logger = new AutoRollLogger(FileSystem::Default(), SystemClock::Default(), - kTestDir, "", log_size, 0, 10); + test_dir_, "", log_size, 0, 10); ASSERT_EQ(logger->GetLogFileSize(), kZero); delete logger; } @@ -269,11 +259,9 @@ TEST_F(AutoRollLoggerTest, CompositeRollByTimeAndSizeLogger) { size_t time = 2, log_max_size = 1024 * 5; size_t keep_log_file_num = 10; - InitTestDb(); - auto nsc = std::make_shared(SystemClock::Default(), true); - AutoRollLogger logger(FileSystem::Default(), nsc, kTestDir, "", log_max_size, + AutoRollLogger logger(FileSystem::Default(), nsc, test_dir_, "", log_max_size, time, keep_log_file_num); // Test the ability to roll by size @@ -292,18 +280,17 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { DBOptions options; auto nsc = std::make_shared(SystemClock::Default(), true); - std::unique_ptr nse(new CompositeEnvWrapper(Env::Default(), nsc)); + std::unique_ptr nse(new CompositeEnvWrapper(env_, nsc)); std::shared_ptr logger; // Normal logger - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); ASSERT_TRUE(dynamic_cast(logger.get())); // Only roll by size - InitTestDb(); options.max_log_file_size = 1024; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); AutoRollLogger* auto_roll_logger = dynamic_cast(logger.get()); ASSERT_TRUE(auto_roll_logger); @@ -313,10 +300,10 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { // Only roll by Time options.env = nse.get(); - InitTestDb(); + options.max_log_file_size = 0; options.log_file_time_to_roll = 2; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); auto_roll_logger = dynamic_cast(logger.get()); RollLogFileByTimeTest(options.env->GetFileSystem(), nsc, auto_roll_logger, @@ -324,10 +311,10 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { kSampleMessage + ":CreateLoggerFromOptions - time"); // roll by both Time and size - InitTestDb(); + RecreateLogDir(); options.max_log_file_size = 1024 * 5; options.log_file_time_to_roll = 2; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); auto_roll_logger = dynamic_cast(logger.get()); RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size, @@ -339,11 +326,11 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { // Set keep_log_file_num { const size_t kFileNum = 3; - InitTestDb(); + RecreateLogDir(); options.max_log_file_size = 512; options.log_file_time_to_roll = 2; options.keep_log_file_num = kFileNum; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); auto_roll_logger = dynamic_cast(logger.get()); // Roll the log 4 times, and it will trim to 3 files. @@ -366,11 +353,11 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { // db_log_dir. { const size_t kFileNum = 3; - InitTestDb(); + RecreateLogDir(); options.max_log_file_size = 512; options.log_file_time_to_roll = 2; options.keep_log_file_num = kFileNum; - options.db_log_dir = kTestDir; + options.db_log_dir = test_dir_; ASSERT_OK(CreateLoggerFromOptions("/dummy/db/name", options, &logger)); auto_roll_logger = dynamic_cast(logger.get()); @@ -399,10 +386,10 @@ TEST_F(AutoRollLoggerTest, AutoDeleting) { for (int attempt = 0; attempt < 2; attempt++) { // In the first attemp, db_log_dir is not set, while in the // second it is set. - std::string dbname = (attempt == 0) ? kTestDir : "/test/dummy/dir"; - std::string db_log_dir = (attempt == 0) ? "" : kTestDir; + std::string dbname = (attempt == 0) ? test_dir_ : "/test/dummy/dir"; + std::string db_log_dir = (attempt == 0) ? "" : test_dir_; - InitTestDb(); + RecreateLogDir(); const size_t kMaxFileSize = 512; { size_t log_num = 8; @@ -442,9 +429,8 @@ TEST_F(AutoRollLoggerTest, LogFlushWhileRolling) { DBOptions options; std::shared_ptr logger; - InitTestDb(); options.max_log_file_size = 1024 * 5; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); AutoRollLogger* auto_roll_logger = dynamic_cast(logger.get()); ASSERT_TRUE(auto_roll_logger); @@ -482,15 +468,13 @@ TEST_F(AutoRollLoggerTest, LogFlushWhileRolling) { #endif // OS_WIN TEST_F(AutoRollLoggerTest, InfoLogLevel) { - InitTestDb(); - size_t log_size = 8192; size_t log_lines = 0; // an extra-scope to force the AutoRollLogger to flush the log file when it // becomes out of scope. { AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), - kTestDir, "", log_size, 0, 10); + test_dir_, "", log_size, 0, 10); for (int log_level = InfoLogLevel::HEADER_LEVEL; log_level >= InfoLogLevel::DEBUG_LEVEL; log_level--) { logger.SetInfoLogLevel((InfoLogLevel)log_level); @@ -516,7 +500,7 @@ TEST_F(AutoRollLoggerTest, InfoLogLevel) { log_lines += InfoLogLevel::HEADER_LEVEL - log_level + 1; } } - std::ifstream inFile(AutoRollLoggerTest::kLogFile.c_str()); + std::ifstream inFile(log_file_.c_str()); size_t lines = std::count(std::istreambuf_iterator(inFile), std::istreambuf_iterator(), '\n'); ASSERT_EQ(log_lines, lines); @@ -524,12 +508,10 @@ TEST_F(AutoRollLoggerTest, InfoLogLevel) { } TEST_F(AutoRollLoggerTest, Close) { - InitTestDb(); - size_t log_size = 8192; size_t log_lines = 0; - AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), kTestDir, - "", log_size, 0, 10); + AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), + test_dir_, "", log_size, 0, 10); for (int log_level = InfoLogLevel::HEADER_LEVEL; log_level >= InfoLogLevel::DEBUG_LEVEL; log_level--) { logger.SetInfoLogLevel((InfoLogLevel)log_level); @@ -556,7 +538,7 @@ TEST_F(AutoRollLoggerTest, Close) { } ASSERT_EQ(logger.Close(), Status::OK()); - std::ifstream inFile(AutoRollLoggerTest::kLogFile.c_str()); + std::ifstream inFile(log_file_.c_str()); size_t lines = std::count(std::istreambuf_iterator(inFile), std::istreambuf_iterator(), '\n'); ASSERT_EQ(log_lines, lines); @@ -565,14 +547,15 @@ TEST_F(AutoRollLoggerTest, Close) { // Test the logger Header function for roll over logs // We expect the new logs creates as roll over to carry the headers specified -static std::vector GetOldFileNames(const std::string& path) { +static std::vector GetOldFileNames(Env* env, + const std::string& path) { std::vector ret; const std::string dirname = path.substr(/*start=*/0, path.find_last_of("/")); const std::string fname = path.substr(path.find_last_of("/") + 1); std::vector children; - EXPECT_OK(Env::Default()->GetChildren(dirname, &children)); + EXPECT_OK(env->GetChildren(dirname, &children)); // We know that the old log files are named [path] // Return all entities that match the pattern @@ -593,11 +576,10 @@ TEST_F(AutoRollLoggerTest, LogHeaderTest) { // test_num == 0 -> standard call to Header() // test_num == 1 -> call to Log() with InfoLogLevel::HEADER_LEVEL for (int test_num = 0; test_num < 2; test_num++) { - - InitTestDb(); + RecreateLogDir(); AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), - kTestDir, /*db_log_dir=*/"", LOG_MAX_SIZE, + test_dir_, /*db_log_dir=*/"", LOG_MAX_SIZE, /*log_file_time_to_roll=*/0, /*keep_log_file_num=*/10); @@ -629,7 +611,7 @@ TEST_F(AutoRollLoggerTest, LogHeaderTest) { // Flush the log for the latest file LogFlush(&logger); - const auto oldfiles = GetOldFileNames(newfname); + const auto oldfiles = GetOldFileNames(env_, newfname); ASSERT_EQ(oldfiles.size(), (size_t) 2); @@ -645,22 +627,14 @@ TEST_F(AutoRollLoggerTest, LogHeaderTest) { TEST_F(AutoRollLoggerTest, LogFileExistence) { ROCKSDB_NAMESPACE::DB* db; ROCKSDB_NAMESPACE::Options options; -#ifdef OS_WIN - // Replace all slashes in the path so windows CompSpec does not - // become confused - std::string testDir(kTestDir); - std::replace_if(testDir.begin(), testDir.end(), - [](char ch) { return ch == '/'; }, '\\'); - std::string deleteCmd = "if exist " + testDir + " rd /s /q " + testDir; -#else - std::string deleteCmd = "rm -rf " + kTestDir; -#endif - ASSERT_EQ(system(deleteCmd.c_str()), 0); + + ASSERT_OK(DestroyDir(env_, test_dir_)); options.max_log_file_size = 100 * 1024 * 1024; options.create_if_missing = true; - ASSERT_OK(ROCKSDB_NAMESPACE::DB::Open(options, kTestDir, &db)); - ASSERT_OK(default_env->FileExists(kLogFile)); + ASSERT_OK(ROCKSDB_NAMESPACE::DB::Open(options, test_dir_, &db)); + ASSERT_OK(env_->FileExists(log_file_)); delete db; + ASSERT_OK(DestroyDB(test_dir_, options)); } TEST_F(AutoRollLoggerTest, FileCreateFailure) { @@ -674,29 +648,27 @@ TEST_F(AutoRollLoggerTest, FileCreateFailure) { } TEST_F(AutoRollLoggerTest, RenameOnlyWhenExists) { - InitTestDb(); - SpecialEnv env(Env::Default()); + SpecialEnv env(env_); Options options; options.env = &env; // Originally no LOG exists. Should not see a rename. { std::shared_ptr logger; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); ASSERT_EQ(0, env.rename_count_); } // Now a LOG exists. Create a new one should see a rename. { std::shared_ptr logger; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); ASSERT_EQ(1, env.rename_count_); } } TEST_F(AutoRollLoggerTest, RenameError) { - InitTestDb(); - SpecialEnv env(Env::Default()); + SpecialEnv env(env_); env.rename_error_ = true; Options options; options.env = &env; @@ -704,14 +676,14 @@ TEST_F(AutoRollLoggerTest, RenameError) { // Originally no LOG exists. Should not be impacted by rename error. { std::shared_ptr logger; - ASSERT_OK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); ASSERT_TRUE(logger != nullptr); } // Now a LOG exists. Rename error should cause failure. { std::shared_ptr logger; - ASSERT_NOK(CreateLoggerFromOptions(kTestDir, options, &logger)); + ASSERT_NOK(CreateLoggerFromOptions(test_dir_, options, &logger)); ASSERT_TRUE(logger == nullptr); } } diff --git a/table/cuckoo/cuckoo_table_builder_test.cc b/table/cuckoo/cuckoo_table_builder_test.cc index 5d6ebfbdd56..42ee8a32753 100644 --- a/table/cuckoo/cuckoo_table_builder_test.cc +++ b/table/cuckoo/cuckoo_table_builder_test.cc @@ -41,6 +41,12 @@ class CuckooBuilderTest : public testing::Test { file_options_ = FileOptions(options); } + ~CuckooBuilderTest() override { + if (!fname.empty()) { + EXPECT_OK(env_->DeleteFile(fname)); + } + } + void CheckFileContents(const std::vector& keys, const std::vector& values, const std::vector& expected_locations, diff --git a/table/cuckoo/cuckoo_table_reader_test.cc b/table/cuckoo/cuckoo_table_reader_test.cc index 5547e6d2723..ce765af7142 100644 --- a/table/cuckoo/cuckoo_table_reader_test.cc +++ b/table/cuckoo/cuckoo_table_reader_test.cc @@ -72,6 +72,12 @@ class CuckooReaderTest : public testing::Test { file_options = FileOptions(options); } + ~CuckooReaderTest() { + if (!fname.empty()) { + env->DeleteFile(fname).PermitUncheckedError(); + } + } + void SetUp(int num) { num_items = num; hash_map.clear(); diff --git a/table/table_test.cc b/table/table_test.cc index 1f314ec7407..536d3b78d39 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -567,10 +567,15 @@ class DBConstructor: public Constructor { explicit DBConstructor(const Comparator* cmp) : Constructor(cmp), comparator_(cmp) { + dbname_ = test::PerThreadDBPath("table_testdb"); db_ = nullptr; NewDB(); } - ~DBConstructor() override { delete db_; } + ~DBConstructor() override { + delete db_; + EXPECT_OK(DestroyDB(dbname_, Options())); + } + Status FinishImpl(const Options& /*options*/, const ImmutableOptions& /*ioptions*/, const MutableCFOptions& /*moptions*/, @@ -596,18 +601,18 @@ class DBConstructor: public Constructor { DB* db() const override { return db_; } private: + std::string dbname_; void NewDB() { - std::string name = test::PerThreadDBPath("table_testdb"); Options options; options.comparator = comparator_; - Status status = DestroyDB(name, options); + Status status = DestroyDB(dbname_, options); ASSERT_TRUE(status.ok()) << status.ToString(); options.create_if_missing = true; options.error_if_exists = true; options.write_buffer_size = 10000; // Something small to force merging - status = DB::Open(options, name, &db_); + status = DB::Open(options, dbname_, &db_); ASSERT_TRUE(status.ok()) << status.ToString(); } @@ -4384,6 +4389,7 @@ TEST_F(PrefixTest, PrefixAndWholeKeyTest) { // Trigger compaction. ASSERT_OK(db->CompactRange(CompactRangeOptions(), nullptr, nullptr)); delete db; + ASSERT_OK(DestroyDB(kDBPath, options)); // In the second round, turn whole_key_filtering off and expect // rocksdb still works. } diff --git a/tools/reduce_levels_test.cc b/tools/reduce_levels_test.cc index 2f7256051c0..6556f494d02 100644 --- a/tools/reduce_levels_test.cc +++ b/tools/reduce_levels_test.cc @@ -22,10 +22,12 @@ class ReduceLevelTest : public testing::Test { public: ReduceLevelTest() { dbname_ = test::PerThreadDBPath("db_reduce_levels_test"); - DestroyDB(dbname_, Options()); + EXPECT_OK(DestroyDB(dbname_, Options())); db_ = nullptr; } + ~ReduceLevelTest() { EXPECT_OK(DestroyDB(dbname_, Options())); } + Status OpenDB(bool create_if_missing, int levels); Status Put(const std::string& k, const std::string& v) { diff --git a/tools/trace_analyzer_test.cc b/tools/trace_analyzer_test.cc index c057c5ab2c2..5bea1b0aaf7 100644 --- a/tools/trace_analyzer_test.cc +++ b/tools/trace_analyzer_test.cc @@ -55,7 +55,7 @@ class TraceAnalyzerTest : public testing::Test { dbname_ = test_path_ + "/db"; } - ~TraceAnalyzerTest() override {} + ~TraceAnalyzerTest() override { EXPECT_OK(DestroyDir(env_, test_path_)); } void GenerateTrace(std::string trace_path) { Options options; diff --git a/utilities/backupable/backupable_db_test.cc b/utilities/backupable/backupable_db_test.cc index f8ff2b34e12..7b9c7e130ab 100644 --- a/utilities/backupable/backupable_db_test.cc +++ b/utilities/backupable/backupable_db_test.cc @@ -686,6 +686,12 @@ class BackupEngineTest : public testing::Test { backup_chroot_env_->DeleteFile(latest_backup_).PermitUncheckedError(); } + ~BackupEngineTest() { + EXPECT_OK( + DestroyDir(Env::Default(), test::PerThreadDBPath("db_for_backup"))); + EXPECT_OK(DestroyDir(Env::Default(), test::PerThreadDBPath("db_backups"))); + } + DB* OpenDB() { DB* db; EXPECT_OK(DB::Open(options_, dbname_, &db)); diff --git a/utilities/checkpoint/checkpoint_test.cc b/utilities/checkpoint/checkpoint_test.cc index 18c437dbbc8..a0d9548acb2 100644 --- a/utilities/checkpoint/checkpoint_test.cc +++ b/utilities/checkpoint/checkpoint_test.cc @@ -745,6 +745,7 @@ TEST_F(CheckpointTest, CurrentFileModifiedWhileCheckpointing2PC) { delete snapshotDB; snapshotDB = nullptr; delete txdb; + ASSERT_OK(DestroyDB(dbname, CurrentOptions())); } TEST_F(CheckpointTest, CheckpointInvalidDirectoryName) { diff --git a/utilities/memory/memory_test.cc b/utilities/memory/memory_test.cc index bef22fc2f35..39c8ef99ebf 100644 --- a/utilities/memory/memory_test.cc +++ b/utilities/memory/memory_test.cc @@ -21,9 +21,23 @@ namespace ROCKSDB_NAMESPACE { class MemoryTest : public testing::Test { public: MemoryTest() : kDbDir(test::PerThreadDBPath("memory_test")), rnd_(301) { - assert(Env::Default()->CreateDirIfMissing(kDbDir).ok()); + EXPECT_OK(Env::Default()->CreateDirIfMissing(kDbDir)); + Options opt; + for (int i = 0; i < kNumDBs; ++i) { + EXPECT_OK(DestroyDB(GetDBName(i), opt)); + } + } + + ~MemoryTest() { + Options opt; + for (int i = 0; i < kNumDBs; ++i) { + EXPECT_OK(DestroyDB(GetDBName(i), opt)); + } + EXPECT_OK(Env::Default()->DeleteDir(kDbDir)); } + const int kNumDBs = 10; + std::string GetDBName(int id) { return kDbDir + "db_" + ToString(id); } void UpdateUsagesHistory(const std::vector& dbs) { @@ -92,7 +106,6 @@ class MemoryTest : public testing::Test { TEST_F(MemoryTest, SharedBlockCacheTotal) { std::vector dbs; std::vector usage_by_type; - const int kNumDBs = 10; const int kKeySize = 100; const int kValueSize = 500; Options opt; @@ -145,7 +158,6 @@ TEST_F(MemoryTest, MemTableAndTableReadersTotal) { std::vector dbs; std::vector usage_by_type; std::vector> vec_handles; - const int kNumDBs = 10; // These key/value sizes ensure each KV has its own memtable. Note that the // minimum write_buffer_size allowed is 64 KB. const int kKeySize = 100; diff --git a/utilities/merge_operators/string_append/stringappend_test.cc b/utilities/merge_operators/string_append/stringappend_test.cc index e7963364e13..997790a5d2d 100644 --- a/utilities/merge_operators/string_append/stringappend_test.cc +++ b/utilities/merge_operators/string_append/stringappend_test.cc @@ -30,45 +30,6 @@ namespace ROCKSDB_NAMESPACE { -// Path to the database on file system -const std::string kDbName = test::PerThreadDBPath("stringappend_test"); - -namespace { -// OpenDb opens a (possibly new) rocksdb database with a StringAppendOperator -std::shared_ptr OpenNormalDb(const std::string& delim) { - DB* db; - Options options; - options.create_if_missing = true; - MergeOperator* mergeOperator; - if (delim.size() == 1) { - mergeOperator = new StringAppendOperator(delim[0]); - } else { - mergeOperator = new StringAppendOperator(delim); - } - options.merge_operator.reset(mergeOperator); - EXPECT_OK(DB::Open(options, kDbName, &db)); - return std::shared_ptr(db); -} - -#ifndef ROCKSDB_LITE // TtlDb is not supported in Lite -// Open a TtlDB with a non-associative StringAppendTESTOperator -std::shared_ptr OpenTtlDb(const std::string& delim) { - DBWithTTL* db; - Options options; - options.create_if_missing = true; - MergeOperator* mergeOperator; - if (delim.size() == 1) { - mergeOperator = new StringAppendTESTOperator(delim[0]); - } else { - mergeOperator = new StringAppendTESTOperator(delim); - } - options.merge_operator.reset(mergeOperator); - EXPECT_OK(DBWithTTL::Open(options, kDbName, &db, 123456)); - return std::shared_ptr(db); -} -#endif // !ROCKSDB_LITE -} // namespace - /// StringLists represents a set of string-lists, each with a key-index. /// Supports Append(list, string) and Get(list) class StringLists { @@ -131,36 +92,48 @@ class StringLists { class StringAppendOperatorTest : public testing::Test, public ::testing::WithParamInterface { public: - StringAppendOperatorTest() { + StringAppendOperatorTest() : use_ttl_(false) { + dbname_ = test::PerThreadDBPath("stringappend_test"); EXPECT_OK( - DestroyDB(kDbName, Options())); // Start each test with a fresh DB - } - - void SetUp() override { + DestroyDB(dbname_, Options())); // Start each test with a fresh DB #ifndef ROCKSDB_LITE // TtlDb is not supported in Lite - bool if_use_ttl = GetParam(); - if (if_use_ttl) { + use_ttl_ = GetParam(); +#endif // !ROCKSDB_LITE + if (use_ttl_) { fprintf(stderr, "Running tests with ttl db and generic operator.\n"); - StringAppendOperatorTest::SetOpenDbFunction(&OpenTtlDb); - return; + } else { + fprintf(stderr, "Running tests with regular db and operator.\n"); } -#endif // !ROCKSDB_LITE - fprintf(stderr, "Running tests with regular db and operator.\n"); - StringAppendOperatorTest::SetOpenDbFunction(&OpenNormalDb); } - using OpenFuncPtr = std::shared_ptr (*)(const std::string&); + ~StringAppendOperatorTest() { + EXPECT_OK(DestroyDB(dbname_, Options())); // Clean up after ourselves + } - // Allows user to open databases with different configurations. - // e.g.: Can open a DB or a TtlDB, etc. - static void SetOpenDbFunction(OpenFuncPtr func) { - OpenDb = func; + std::shared_ptr OpenDb(const std::string& delim) { + Options options; + options.create_if_missing = true; + if (delim.size() == 1) { + options.merge_operator.reset(new StringAppendTESTOperator(delim[0])); + } else { + options.merge_operator.reset(new StringAppendTESTOperator(delim)); + } +#ifndef ROCKSDB_LITE // TtlDb is not supported in Lite + if (use_ttl_) { + DBWithTTL* dbttl; + EXPECT_OK(DBWithTTL::Open(options, dbname_, &dbttl, 123456)); + return std::shared_ptr(dbttl); + } +#endif // ROCKSDB_LITE + DB* db; + EXPECT_OK(DB::Open(options, dbname_, &db)); + return std::shared_ptr(db); } - protected: - static OpenFuncPtr OpenDb; + private: + bool use_ttl_; + std::string dbname_; }; -StringAppendOperatorTest::OpenFuncPtr StringAppendOperatorTest::OpenDb = nullptr; // THE TEST CASES BEGIN HERE diff --git a/utilities/options/options_util_test.cc b/utilities/options/options_util_test.cc index 2522072fcca..e728992d0bf 100644 --- a/utilities/options/options_util_test.cc +++ b/utilities/options/options_util_test.cc @@ -757,6 +757,7 @@ TEST_F(OptionsUtilTest, WalDirInOptins) { delete db; ASSERT_OK(LoadLatestOptions(dbname_, options.env, &db_opts, &cf_descs)); ASSERT_EQ(db_opts.wal_dir, ""); + ASSERT_OK(DestroyDB(dbname_, options)); } } // namespace ROCKSDB_NAMESPACE diff --git a/utilities/transactions/transaction_test.h b/utilities/transactions/transaction_test.h index ecc8ea1f9fa..4b925a08c8c 100644 --- a/utilities/transactions/transaction_test.h +++ b/utilities/transactions/transaction_test.h @@ -61,6 +61,7 @@ class TransactionTestBase : public ::testing::Test { options.write_buffer_size = 4 * 1024; options.unordered_write = write_ordering == kUnorderedWrite; options.level0_file_num_compaction_trigger = 2; + options.info_log_level = INFO_LEVEL; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); special_env.skip_fsync_ = true; env = new FaultInjectionTestEnv(&special_env); diff --git a/utilities/transactions/write_prepared_transaction_test.cc b/utilities/transactions/write_prepared_transaction_test.cc index f1f65e17a98..69eb0a6afa0 100644 --- a/utilities/transactions/write_prepared_transaction_test.cc +++ b/utilities/transactions/write_prepared_transaction_test.cc @@ -288,6 +288,7 @@ TEST(WriteBatchWithIndex, SubBatchCnt) { delete cf_handle; delete db; + ASSERT_OK(DestroyDB(dbname, options)); } TEST(CommitEntry64b, BasicTest) { From 32af2c01df6033589e0906097f1774f957232735 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 10 Feb 2022 08:09:59 -0500 Subject: [PATCH 02/12] Fix shadow variable --- db/prefix_test.cc | 72 +++++++++++++++++++++++------------------------ 1 file changed, 35 insertions(+), 37 deletions(-) diff --git a/db/prefix_test.cc b/db/prefix_test.cc index 90268d2c635..fd4b9cab476 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -221,24 +221,24 @@ class PrefixTest : public testing::Test { std::shared_ptr OpenDb() { DB* db; - options.create_if_missing = true; - options.write_buffer_size = FLAGS_write_buffer_size; - options.max_write_buffer_number = FLAGS_max_write_buffer_number; - options.min_write_buffer_number_to_merge = - FLAGS_min_write_buffer_number_to_merge; + options_.create_if_missing = true; + options_.write_buffer_size = FLAGS_write_buffer_size; + options_.max_write_buffer_number = FLAGS_max_write_buffer_number; + options_.min_write_buffer_number_to_merge = + FLAGS_min_write_buffer_number_to_merge; - options.memtable_prefix_bloom_size_ratio = + options_.memtable_prefix_bloom_size_ratio = FLAGS_memtable_prefix_bloom_size_ratio; - options.memtable_huge_page_size = FLAGS_memtable_huge_page_size; + options_.memtable_huge_page_size = FLAGS_memtable_huge_page_size; - options.prefix_extractor.reset(NewFixedPrefixTransform(8)); + options_.prefix_extractor.reset(NewFixedPrefixTransform(8)); BlockBasedTableOptions bbto; bbto.filter_policy.reset(NewBloomFilterPolicy(10, false)); bbto.whole_key_filtering = false; - options.table_factory.reset(NewBlockBasedTableFactory(bbto)); - options.allow_concurrent_memtable_write = false; + options_.table_factory.reset(NewBlockBasedTableFactory(bbto)); + options_.allow_concurrent_memtable_write = false; - Status s = DB::Open(options, dbname_, &db); + Status s = DB::Open(options_, dbname_, &db); EXPECT_OK(s); return std::shared_ptr(db); } @@ -251,22 +251,22 @@ class PrefixTest : public testing::Test { // skip some options option_config_++; if (option_config_ < kEnd) { - options.prefix_extractor.reset(NewFixedPrefixTransform(8)); + options_.prefix_extractor.reset(NewFixedPrefixTransform(8)); switch(option_config_) { case kHashSkipList: - options.memtable_factory.reset( + options_.memtable_factory.reset( NewHashSkipListRepFactory(bucket_count, FLAGS_skiplist_height)); return true; case kHashLinkList: - options.memtable_factory.reset( + options_.memtable_factory.reset( NewHashLinkListRepFactory(bucket_count)); return true; case kHashLinkListHugePageTlb: - options.memtable_factory.reset( + options_.memtable_factory.reset( NewHashLinkListRepFactory(bucket_count, 2 * 1024 * 1024)); return true; case kHashLinkListTriggerSkipList: - options.memtable_factory.reset( + options_.memtable_factory.reset( NewHashLinkListRepFactory(bucket_count, 0, 3)); return true; default: @@ -277,14 +277,13 @@ class PrefixTest : public testing::Test { } PrefixTest() : option_config_(kBegin) { - options.comparator = new TestKeyComparator(); + options_.comparator = new TestKeyComparator(); dbname_ = ROCKSDB_NAMESPACE::test::PerThreadDBPath("prefix_test"); - EXPECT_OK(DestroyDB(dbname_, options)); - EXPECT_OK(DestroyDB(dbname_, options)); + EXPECT_OK(DestroyDB(dbname_, options_)); } ~PrefixTest() override { - EXPECT_OK(DestroyDB(dbname_, options)); - delete options.comparator; + EXPECT_OK(DestroyDB(dbname_, options_)); + delete options_.comparator; } std::string dbname_; @@ -299,7 +298,7 @@ class PrefixTest : public testing::Test { kEnd }; int option_config_; - Options options; + Options options_; }; TEST_F(PrefixTest, InDomainTest) { @@ -356,9 +355,8 @@ TEST_F(PrefixTest, TestResult) { for (int num_buckets = 1; num_buckets <= 2; num_buckets++) { FirstOption(); while (NextOptions(num_buckets)) { - std::cout << "*** Mem table: " << options.memtable_factory->Name() - << " number of buckets: " << num_buckets - << std::endl; + std::cout << "*** Mem table: " << options_.memtable_factory->Name() + << " number of buckets: " << num_buckets << std::endl; ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; @@ -534,7 +532,7 @@ TEST_F(PrefixTest, PrefixValid) { for (int num_buckets = 1; num_buckets <= 2; num_buckets++) { FirstOption(); while (NextOptions(num_buckets)) { - std::cout << "*** Mem table: " << options.memtable_factory->Name() + std::cout << "*** Mem table: " << options_.memtable_factory->Name() << " number of buckets: " << num_buckets << std::endl; ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); @@ -587,8 +585,8 @@ TEST_F(PrefixTest, PrefixValid) { TEST_F(PrefixTest, DynamicPrefixIterator) { while (NextOptions(FLAGS_bucket_count)) { - std::cout << "*** Mem table: " << options.memtable_factory->Name() - << std::endl; + std::cout << "*** Mem table: " << options_.memtable_factory->Name() + << std::endl; ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; @@ -639,7 +637,7 @@ TEST_F(PrefixTest, DynamicPrefixIterator) { get_perf_context()->Reset(); StopWatchNano timer(SystemClock::Default().get(), true); - auto key_prefix = options.prefix_extractor->Transform(key); + auto key_prefix = options_.prefix_extractor->Transform(key); uint64_t total_keys = 0; for (iter->Seek(key); iter->Valid() && iter->key().starts_with(key_prefix); @@ -689,13 +687,13 @@ TEST_F(PrefixTest, DynamicPrefixIterator) { TEST_F(PrefixTest, PrefixSeekModePrev) { // Only for SkipListFactory - options.memtable_factory.reset(new SkipListFactory); - options.merge_operator = MergeOperators::CreatePutOperator(); - options.write_buffer_size = 1024 * 1024; + options_.memtable_factory.reset(new SkipListFactory); + options_.merge_operator = MergeOperators::CreatePutOperator(); + options_.write_buffer_size = 1024 * 1024; Random rnd(1); for (size_t m = 1; m < 100; m++) { std::cout << "[" + std::to_string(m) + "]" + "*** Mem table: " - << options.memtable_factory->Name() << std::endl; + << options_.memtable_factory->Name() << std::endl; ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); WriteOptions write_options; @@ -810,8 +808,8 @@ TEST_F(PrefixTest, PrefixSeekModePrev2) { // after seek(15), iter1 will be at 21 and iter2 will be 33. // Then if call Prev() in prefix mode where SeekForPrev(21) gets called, // iter2 should turn to invalid state because of bloom filter. - options.memtable_factory.reset(new SkipListFactory); - options.write_buffer_size = 1024 * 1024; + options_.memtable_factory.reset(new SkipListFactory); + options_.write_buffer_size = 1024 * 1024; std::string v13("v13"); ASSERT_OK(DestroyDB(dbname_, Options())); auto db = OpenDb(); @@ -841,8 +839,8 @@ TEST_F(PrefixTest, PrefixSeekModePrev2) { TEST_F(PrefixTest, PrefixSeekModePrev3) { // Only for SkipListFactory // test SeekToLast() with iterate_upper_bound_ in prefix_seek_mode - options.memtable_factory.reset(new SkipListFactory); - options.write_buffer_size = 1024 * 1024; + options_.memtable_factory.reset(new SkipListFactory); + options_.write_buffer_size = 1024 * 1024; std::string v14("v14"); TestKey upper_bound_key = TestKey(1, 5); std::string s; From 4e2b4754e5d2e6b2f52c4d9710129a2f5efec2ff Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 10 Feb 2022 15:41:32 -0500 Subject: [PATCH 03/12] Fix/Revert env_test --- env/env_test.cc | 43 ++++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/env/env_test.cc b/env/env_test.cc index 5bb54c407d3..1d027493826 100644 --- a/env/env_test.cc +++ b/env/env_test.cc @@ -110,18 +110,11 @@ class EnvPosixTest : public testing::Test { public: Env* env_; bool direct_io_; - std::string fname_; - - EnvPosixTest() : env_(Env::Default()), direct_io_(false) { - fname_ = test::PerThreadDBPath(env_, "testfile"); - } + EnvPosixTest() : env_(Env::Default()), direct_io_(false) {} ~EnvPosixTest() { SyncPoint::GetInstance()->DisableProcessing(); SyncPoint::GetInstance()->LoadDependency({}); SyncPoint::GetInstance()->ClearAllCallBacks(); - if (env_->FileExists(fname_).ok()) { - EXPECT_OK(env_->DeleteFile(fname_)); - } } }; @@ -320,10 +313,11 @@ TEST_F(EnvPosixTest, LowerThreadPoolCpuPriority) { TEST_F(EnvPosixTest, MemoryMappedFileBuffer) { const int kFileBytes = 1 << 15; // 32 KB std::string expected_data; + std::string fname = test::PerThreadDBPath(env_, "testfile"); { std::unique_ptr wfile; const EnvOptions soptions; - ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); Random rnd(301); expected_data = rnd.RandomString(kFileBytes); @@ -331,7 +325,7 @@ TEST_F(EnvPosixTest, MemoryMappedFileBuffer) { } std::unique_ptr mmap_buffer; - Status status = env_->NewMemoryMappedFileBuffer(fname_, &mmap_buffer); + Status status = env_->NewMemoryMappedFileBuffer(fname, &mmap_buffer); // it should be supported at least on linux #if !defined(OS_LINUX) if (status.IsNotSupported()) { @@ -1234,6 +1228,7 @@ TEST_P(EnvPosixTestWithParam, DISABLED_RandomAccessUniqueIDDeletes) { TEST_P(EnvPosixTestWithParam, MultiRead) { EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = direct_io_; + std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kSectorSize = 4096; const size_t kNumSectors = 8; @@ -1247,7 +1242,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) { soptions.use_direct_writes = false; } #endif - ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); for (size_t i = 0; i < kNumSectors; ++i) { auto data = NewAligned(kSectorSize * 8, static_cast(i + 1)); Slice slice(data.get(), kSectorSize); @@ -1292,7 +1287,7 @@ TEST_P(EnvPosixTestWithParam, MultiRead) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); ASSERT_OK(file->MultiRead(reqs.data(), reqs.size())); for (size_t i = 0; i < reqs.size(); ++i) { auto buf = NewAligned(kSectorSize * 8, static_cast(i * 2 + 1)); @@ -1308,6 +1303,7 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // direct I/O case. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; + std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kTotalSize = 81920; Random rnd(301); @@ -1316,7 +1312,7 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // Create file. { std::unique_ptr wfile; - ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); ASSERT_OK(wfile->Append(expected_data)); ASSERT_OK(wfile->Close()); } @@ -1380,7 +1376,7 @@ TEST_F(EnvPosixTest, MultiReadNonAlignedLargeNum) { // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); ASSERT_OK(file->MultiRead(reqs.data(), reqs.size())); // Validate results @@ -1434,13 +1430,14 @@ TEST_F(EnvPosixTest, MultiReadIOUringError) { // In this test we don't do aligned read, so we can't do direct I/O. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; + std::string fname = test::PerThreadDBPath(env_, "testfile"); std::vector scratches; std::vector reqs; - GenerateFilesAndRequest(env_, fname_, &reqs, &scratches); + GenerateFilesAndRequest(env_, fname, &reqs, &scratches); // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); bool io_uring_wait_cqe_called = false; SyncPoint::GetInstance()->SetCallBack( @@ -1469,13 +1466,14 @@ TEST_F(EnvPosixTest, MultiReadIOUringError2) { // In this test we don't do aligned read, so we can't do direct I/O. EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = false; + std::string fname = test::PerThreadDBPath(env_, "testfile"); std::vector scratches; std::vector reqs; - GenerateFilesAndRequest(env_, fname_, &reqs, &scratches); + GenerateFilesAndRequest(env_, fname, &reqs, &scratches); // Query the data std::unique_ptr file; - ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); bool io_uring_submit_and_wait_called = false; SyncPoint::GetInstance()->SetCallBack( @@ -1516,6 +1514,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing(); EnvOptions soptions; soptions.use_direct_reads = soptions.use_direct_writes = direct_io_; + std::string fname = test::PerThreadDBPath(env_, "testfile"); const size_t kSectorSize = 512; auto data = NewAligned(kSectorSize, 0); @@ -1529,7 +1528,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_writes = false; } #endif - ASSERT_OK(env_->NewWritableFile(fname_, &wfile, soptions)); + ASSERT_OK(env_->NewWritableFile(fname, &wfile, soptions)); ASSERT_OK(wfile->Append(slice)); ASSERT_OK(wfile->InvalidateCache(0, 0)); ASSERT_OK(wfile->Close()); @@ -1545,7 +1544,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewRandomAccessFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewRandomAccessFile(fname, &file, soptions)); ASSERT_OK(file->Read(0, kSectorSize, &result, scratch.get())); ASSERT_EQ(memcmp(scratch.get(), data.get(), kSectorSize), 0); ASSERT_OK(file->InvalidateCache(0, 11)); @@ -1562,7 +1561,7 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { soptions.use_direct_reads = false; } #endif - ASSERT_OK(env_->NewSequentialFile(fname_, &file, soptions)); + ASSERT_OK(env_->NewSequentialFile(fname, &file, soptions)); if (file->use_direct_io()) { ASSERT_OK(file->PositionedRead(0, kSectorSize, &result, scratch.get())); } else { @@ -1572,6 +1571,8 @@ TEST_P(EnvPosixTestWithParam, InvalidateCache) { ASSERT_OK(file->InvalidateCache(0, 11)); ASSERT_OK(file->InvalidateCache(0, 0)); } + // Delete the file + ASSERT_OK(env_->DeleteFile(fname)); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearTrace(); } #endif // not TRAVIS From 945bc2b6b1278cba521d9869c213d083cd8d20db Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 28 Apr 2022 14:46:41 -0400 Subject: [PATCH 04/12] Fix merge issue --- db/compact_files_test.cc | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/db/compact_files_test.cc b/db/compact_files_test.cc index 5ec8760218e..b3093cf20c9 100644 --- a/db/compact_files_test.cc +++ b/db/compact_files_test.cc @@ -143,11 +143,12 @@ TEST_F(CompactFilesTest, MultipleLevel) { // create couple files in L0, L3, L4 and L5 for (int i = 5; i > 2; --i) { collector->ClearFlushedFiles(); - ASSERT_OK(db->Put(WriteOptions(), ToString(i), "")); - ASSERT_OK(db->Flush(FlushOptions())); + ASSERT_OK(db_->Put(WriteOptions(), ToString(i), "")); + ASSERT_OK(db_->Flush(FlushOptions())); // Ensure background work is fully finished including listener callbacks // before accessing listener state. - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForBackgroundWork()); + ASSERT_OK( + static_cast_with_check(db_)->TEST_WaitForBackgroundWork()); auto l0_files = collector->GetFlushedFiles(); ASSERT_OK(db_->CompactFiles(CompactionOptions(), l0_files, i)); @@ -286,7 +287,7 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) { // Ensure background work is fully finished including listener callbacks // before accessing listener state. - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForBackgroundWork()); + ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForBackgroundWork()); auto l0_files = collector->GetFlushedFiles(); EXPECT_EQ(5, l0_files.size()); @@ -392,7 +393,8 @@ TEST_F(CompactFilesTest, SentinelCompressionType) { // Ensure background work is fully finished including listener callbacks // before accessing listener state. - ASSERT_OK(static_cast_with_check(db)->TEST_WaitForBackgroundWork()); + ASSERT_OK( + static_cast_with_check(db_)->TEST_WaitForBackgroundWork()); auto l0_files = collector->GetFlushedFiles(); ASSERT_EQ(1, l0_files.size()); From fcd05a50b7dc12a678fa0bbaf7a9718929773d50 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 5 May 2022 09:09:27 -0400 Subject: [PATCH 05/12] Fix Merge --- db/db_block_cache_test.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/db/db_block_cache_test.cc b/db/db_block_cache_test.cc index 518105af2aa..640a0c0cd87 100644 --- a/db/db_block_cache_test.cc +++ b/db/db_block_cache_test.cc @@ -1714,6 +1714,11 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) { #endif // !ROCKSDB_LITE Close(); + // Delete the external files + for (const auto & e : external) { + Status s = options.env->DeleteFile(e); + ASSERT_TRUE(s.IsNotFound() || s.ok()); + } Destroy(options); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); } From 7839c0a34ce4cf6660211610cc0f9fb56cde1ffc Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 5 May 2022 10:48:19 -0400 Subject: [PATCH 06/12] Fix build errors --- db/db_block_cache_test.cc | 4 +++- utilities/backup/backup_engine_test.cc | 3 +-- utilities/memory/memory_test.cc | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/db/db_block_cache_test.cc b/db/db_block_cache_test.cc index 640a0c0cd87..ec65374f257 100644 --- a/db/db_block_cache_test.cc +++ b/db/db_block_cache_test.cc @@ -1714,11 +1714,13 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) { #endif // !ROCKSDB_LITE Close(); +#ifndef ROCKSDB_LITE // Delete the external files - for (const auto & e : external) { + for (const auto& e : external) { Status s = options.env->DeleteFile(e); ASSERT_TRUE(s.IsNotFound() || s.ok()); } +#endif // ROCKSDB_LITE Destroy(options); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); } diff --git a/utilities/backup/backup_engine_test.cc b/utilities/backup/backup_engine_test.cc index 1a30354f1e0..63e96027cb6 100644 --- a/utilities/backup/backup_engine_test.cc +++ b/utilities/backup/backup_engine_test.cc @@ -664,13 +664,12 @@ class BackupEngineTest : public testing::Test { backup_chroot_env_->DeleteFile(latest_backup_).PermitUncheckedError(); } - ~BackupEngineTest() { EXPECT_OK( DestroyDir(Env::Default(), test::PerThreadDBPath("db_for_backup"))); EXPECT_OK(DestroyDir(Env::Default(), test::PerThreadDBPath("db_backups"))); } - + void SetEnvsFromFileSystems() { db_chroot_env_.reset( new CompositeEnvWrapper(Env::Default(), db_chroot_fs_)); diff --git a/utilities/memory/memory_test.cc b/utilities/memory/memory_test.cc index 39c8ef99ebf..1a746eb20dd 100644 --- a/utilities/memory/memory_test.cc +++ b/utilities/memory/memory_test.cc @@ -36,7 +36,7 @@ class MemoryTest : public testing::Test { EXPECT_OK(Env::Default()->DeleteDir(kDbDir)); } - const int kNumDBs = 10; + constexpr int kNumDBs = 10; std::string GetDBName(int id) { return kDbDir + "db_" + ToString(id); } From c9f89bc313a65f7a7c2d929b755f6405ddbcf562 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Thu, 5 May 2022 13:32:52 -0400 Subject: [PATCH 07/12] Fix compilation --- utilities/memory/memory_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utilities/memory/memory_test.cc b/utilities/memory/memory_test.cc index 1a746eb20dd..6dee4bd4bed 100644 --- a/utilities/memory/memory_test.cc +++ b/utilities/memory/memory_test.cc @@ -36,7 +36,7 @@ class MemoryTest : public testing::Test { EXPECT_OK(Env::Default()->DeleteDir(kDbDir)); } - constexpr int kNumDBs = 10; + static constexpr int kNumDBs = 10; std::string GetDBName(int id) { return kDbDir + "db_" + ToString(id); } From 729ac68ddbc008a0125466d5bf96fda1ec4c7174 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Tue, 10 May 2022 18:34:34 -0400 Subject: [PATCH 08/12] make format --- db/compact_files_test.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/db/compact_files_test.cc b/db/compact_files_test.cc index 146a3656bee..ca4cd30e0d2 100644 --- a/db/compact_files_test.cc +++ b/db/compact_files_test.cc @@ -220,7 +220,7 @@ TEST_F(CompactFilesTest, ObsoleteFiles) { // create couple files for (int i = 1000; i < 2000; ++i) { ASSERT_OK(db_->Put(WriteOptions(), std::to_string(i), - std::string(kWriteBufferSize / 10, 'a' + (i % 26)))); + std::string(kWriteBufferSize / 10, 'a' + (i % 26)))); } auto l0_files = collector->GetFlushedFiles(); @@ -252,14 +252,14 @@ TEST_F(CompactFilesTest, NotCutOutputOnLevel0) { // create couple files for (int i = 0; i < 500; ++i) { ASSERT_OK(db_->Put(WriteOptions(), std::to_string(i), - std::string(1000, 'a' + (i % 26)))); + std::string(1000, 'a' + (i % 26)))); } ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForFlushMemTable()); auto l0_files_1 = collector->GetFlushedFiles(); collector->ClearFlushedFiles(); for (int i = 0; i < 500; ++i) { ASSERT_OK(db_->Put(WriteOptions(), std::to_string(i), - std::string(1000, 'a' + (i % 26)))); + std::string(1000, 'a' + (i % 26)))); } ASSERT_OK(static_cast_with_check(db_)->TEST_WaitForFlushMemTable()); auto l0_files_2 = collector->GetFlushedFiles(); From 49b43b01ec5bcf543627f78b42f6da7c318ec200 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Tue, 10 May 2022 18:51:16 -0400 Subject: [PATCH 09/12] Fix to_string in test --- db/listener_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/db/listener_test.cc b/db/listener_test.cc index dd1c8b03e7c..059e5ffadd6 100644 --- a/db/listener_test.cc +++ b/db/listener_test.cc @@ -496,7 +496,7 @@ TEST_F(EventListenerTest, MultiDBMultiListeners) { delete db; } for (int d = 0; d < kNumDBs; ++d) { - ASSERT_OK(DestroyDB(dbname_ + ToString(d), options)); + ASSERT_OK(DestroyDB(dbname_ + std::to_string(d), options)); } } From 113e34a9415c909259eae14f03d8b87150ea0a7e Mon Sep 17 00:00:00 2001 From: mrambacher Date: Tue, 9 Aug 2022 10:15:52 -0400 Subject: [PATCH 10/12] Fix merge issue --- logging/auto_roll_logger_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/logging/auto_roll_logger_test.cc b/logging/auto_roll_logger_test.cc index bc918178e09..2f317b2f330 100644 --- a/logging/auto_roll_logger_test.cc +++ b/logging/auto_roll_logger_test.cc @@ -363,7 +363,7 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { options.max_log_file_size = 512; options.log_file_time_to_roll = 2; options.keep_log_file_num = kFileNum; - options.db_log_dir = kTestDir; + options.db_log_dir = test_dir_; ASSERT_OK(CreateLoggerFromOptions(test_db_dir_, options, &logger)); auto_roll_logger = dynamic_cast(logger.get()); From 142228926c897f5c6bfeb65a250a925001d0e2b0 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Tue, 9 Aug 2022 10:33:51 -0400 Subject: [PATCH 11/12] Another make format --- db/prefix_test.cc | 1 - logging/auto_roll_logger_test.cc | 14 +++++++------- table/table_test.cc | 1 - 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/db/prefix_test.cc b/db/prefix_test.cc index 3d35ca88394..73bed665780 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -54,7 +54,6 @@ DEFINE_int32(memtable_huge_page_size, 2 * 1024 * 1024, ""); DEFINE_int32(value_size, 40, ""); DEFINE_bool(enable_print, false, "Print options generated to console."); - namespace ROCKSDB_NAMESPACE { struct TestKey { diff --git a/logging/auto_roll_logger_test.cc b/logging/auto_roll_logger_test.cc index 2f317b2f330..8fe54617b43 100644 --- a/logging/auto_roll_logger_test.cc +++ b/logging/auto_roll_logger_test.cc @@ -55,7 +55,7 @@ class AutoRollLoggerTest : public testing::Test { test_dir_ = test::PerThreadDBPath(env_, "db_log_test"); log_file_ = test_dir_ + "/LOG"; test_db_dir_ = test::PerThreadDBPath(env_, "db_log_test_db"); - + RecreateLogDir(); } @@ -189,14 +189,14 @@ void AutoRollLoggerTest::RollLogFileByTimeTest( } TEST_F(AutoRollLoggerTest, RollLogFileBySize) { - size_t log_max_size = 1024 * 5; - size_t keep_log_file_num = 10; + size_t log_max_size = 1024 * 5; + size_t keep_log_file_num = 10; - AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), - test_dir_, "", log_max_size, 0, keep_log_file_num); + AutoRollLogger logger(FileSystem::Default(), SystemClock::Default(), + test_dir_, "", log_max_size, 0, keep_log_file_num); - RollLogFileBySizeTest(&logger, log_max_size, - kSampleMessage + ":RollLogFileBySize"); + RollLogFileBySizeTest(&logger, log_max_size, + kSampleMessage + ":RollLogFileBySize"); } TEST_F(AutoRollLoggerTest, RollLogFileByTime) { diff --git a/table/table_test.cc b/table/table_test.cc index 2ff3fc71965..4a5596b26e8 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -607,7 +607,6 @@ class DBConstructor: public Constructor { private: std::string dbname_; void NewDB() { - Options options; options.comparator = comparator_; Status status = DestroyDB(dbname_, options); From 730efb3acd4aada16d69cde5ec9a667a8a692c47 Mon Sep 17 00:00:00 2001 From: mrambacher Date: Mon, 9 Jan 2023 09:00:27 -0500 Subject: [PATCH 12/12] Fix format And failing test --- db/compact_files_test.cc | 9 +++++---- db/prefix_test.cc | 2 +- logging/auto_roll_logger_test.cc | 6 ++---- table/table_test.cc | 3 +-- 4 files changed, 9 insertions(+), 11 deletions(-) diff --git a/db/compact_files_test.cc b/db/compact_files_test.cc index 6ce34e1c7d4..2a44adee232 100644 --- a/db/compact_files_test.cc +++ b/db/compact_files_test.cc @@ -94,6 +94,8 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) { options_.level0_file_num_compaction_trigger = kLevel0Trigger; options_.compression = kNoCompression; + OpenDB(); + ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency({ {"CompactFilesImpl:0", "BackgroundCallCompaction:0"}, {"BackgroundCallCompaction:1", "CompactFilesImpl:1"}, @@ -369,10 +371,9 @@ TEST_F(CompactFilesTest, SentinelCompressionType) { } // Check that passing `CompressionType::kDisableCompressionOption` to // `CompactFiles` causes it to use the column family compression options. - for (auto compaction_style : - {CompactionStyle::kCompactionStyleLevel, - CompactionStyle::kCompactionStyleUniversal, - CompactionStyle::kCompactionStyleNone}) { + for (auto compaction_style : {CompactionStyle::kCompactionStyleLevel, + CompactionStyle::kCompactionStyleUniversal, + CompactionStyle::kCompactionStyleNone}) { ASSERT_OK(DestroyDB(db_name_, options_)); options_.compaction_style = compaction_style; // L0: Snappy, L1: ZSTD, L2: Snappy diff --git a/db/prefix_test.cc b/db/prefix_test.cc index 0689c9d061b..2a84faf85eb 100644 --- a/db/prefix_test.cc +++ b/db/prefix_test.cc @@ -247,7 +247,7 @@ class PrefixTest : public testing::Test { option_config_++; if (option_config_ < kEnd) { options_.prefix_extractor.reset(NewFixedPrefixTransform(8)); - switch(option_config_) { + switch (option_config_) { case kHashSkipList: options_.memtable_factory.reset( NewHashSkipListRepFactory(bucket_count, FLAGS_skiplist_height)); diff --git a/logging/auto_roll_logger_test.cc b/logging/auto_roll_logger_test.cc index 9deab965430..6c6581a491e 100644 --- a/logging/auto_roll_logger_test.cc +++ b/logging/auto_roll_logger_test.cc @@ -309,8 +309,7 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { options.max_log_file_size = 0; options.log_file_time_to_roll = 2; ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); - auto_roll_logger = - dynamic_cast(logger.get()); + auto_roll_logger = dynamic_cast(logger.get()); RollLogFileByTimeTest(options.env->GetFileSystem(), nsc, auto_roll_logger, options.log_file_time_to_roll, kSampleMessage + ":CreateLoggerFromOptions - time"); @@ -320,8 +319,7 @@ TEST_F(AutoRollLoggerTest, CreateLoggerFromOptions) { options.max_log_file_size = 1024 * 5; options.log_file_time_to_roll = 2; ASSERT_OK(CreateLoggerFromOptions(test_dir_, options, &logger)); - auto_roll_logger = - dynamic_cast(logger.get()); + auto_roll_logger = dynamic_cast(logger.get()); RollLogFileBySizeTest(auto_roll_logger, options.max_log_file_size, kSampleMessage + ":CreateLoggerFromOptions - both"); RollLogFileByTimeTest(options.env->GetFileSystem(), nsc, auto_roll_logger, diff --git a/table/table_test.cc b/table/table_test.cc index adb8332096b..782f4d6cfcc 100644 --- a/table/table_test.cc +++ b/table/table_test.cc @@ -569,8 +569,7 @@ class InternalIteratorFromIterator : public InternalIterator { class DBConstructor : public Constructor { public: explicit DBConstructor(const Comparator* cmp) - : Constructor(cmp), - comparator_(cmp) { + : Constructor(cmp), comparator_(cmp) { dbname_ = test::PerThreadDBPath("table_testdb"); db_ = nullptr; NewDB();