diff --git a/Makefile b/Makefile index 094776391..5ac25b0ce 100644 --- a/Makefile +++ b/Makefile @@ -595,6 +595,10 @@ ifdef ASSERT_STATUS_CHECKED db_basic_test \ db_blob_basic_test \ db_flush_test \ + db_iterator_test \ + db_memtable_test \ + db_merge_operand_test \ + db_merge_operator_test \ db_with_timestamp_basic_test \ db_with_timestamp_compaction_test \ db_options_test \ @@ -677,6 +681,8 @@ ifdef ASSERT_STATUS_CHECKED import_column_family_test \ memory_test \ table_test \ + write_batch_test \ + write_batch_with_index_test \ ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1) TESTS_PASSING_ASC += folly_synchronization_distributed_mutex_test diff --git a/db/db_iterator_test.cc b/db/db_iterator_test.cc index 97d4aefcf..2373963e5 100644 --- a/db/db_iterator_test.cc +++ b/db/db_iterator_test.cc @@ -67,8 +67,8 @@ TEST_P(DBIteratorTest, IteratorProperty) { // The test needs to be changed if kPersistedTier is supported in iterator. Options options = CurrentOptions(); CreateAndReopenWithCF({"pikachu"}, options); - Put(1, "1", "2"); - Delete(1, "2"); + ASSERT_OK(Put(1, "1", "2")); + ASSERT_OK(Delete(1, "2")); ReadOptions ropt; ropt.pin_data = false; { @@ -172,10 +172,10 @@ TEST_P(DBIteratorTest, NonBlockingIteration) { TEST_P(DBIteratorTest, IterSeekBeforePrev) { ASSERT_OK(Put("a", "b")); ASSERT_OK(Put("c", "d")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("0", "f")); ASSERT_OK(Put("1", "h")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("2", "j")); auto iter = NewIterator(ReadOptions()); iter->Seek(Slice("c")); @@ -199,7 +199,7 @@ TEST_P(DBIteratorTest, IterReseekNewUpperBound) { ASSERT_OK(Put("aabb", rnd.RandomString(400))); ASSERT_OK(Put("aaef", rnd.RandomString(400))); ASSERT_OK(Put("b", rnd.RandomString(400))); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ReadOptions opts; Slice ub = Slice("aa"); opts.iterate_upper_bound = &ub; @@ -215,10 +215,10 @@ TEST_P(DBIteratorTest, IterReseekNewUpperBound) { TEST_P(DBIteratorTest, IterSeekForPrevBeforeNext) { ASSERT_OK(Put("a", "b")); ASSERT_OK(Put("c", "d")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("0", "f")); ASSERT_OK(Put("1", "h")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("2", "j")); auto iter = NewIterator(ReadOptions()); iter->SeekForPrev(Slice("0")); @@ -238,7 +238,7 @@ TEST_P(DBIteratorTest, IterLongKeys) { ASSERT_OK(Put(MakeLongKey(20, 0), "0")); ASSERT_OK(Put(MakeLongKey(32, 2), "2")); ASSERT_OK(Put("a", "b")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put(MakeLongKey(50, 1), "1")); ASSERT_OK(Put(MakeLongKey(127, 3), "3")); ASSERT_OK(Put(MakeLongKey(64, 4), "4")); @@ -276,7 +276,7 @@ TEST_P(DBIteratorTest, IterLongKeys) { TEST_P(DBIteratorTest, IterNextWithNewerSeq) { ASSERT_OK(Put("0", "0")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("a", "b")); ASSERT_OK(Put("c", "d")); ASSERT_OK(Put("d", "e")); @@ -302,7 +302,7 @@ TEST_P(DBIteratorTest, IterNextWithNewerSeq) { TEST_P(DBIteratorTest, IterPrevWithNewerSeq) { ASSERT_OK(Put("0", "0")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("a", "b")); ASSERT_OK(Put("c", "d")); ASSERT_OK(Put("d", "e")); @@ -333,7 +333,7 @@ TEST_P(DBIteratorTest, IterPrevWithNewerSeq) { TEST_P(DBIteratorTest, IterPrevWithNewerSeq2) { ASSERT_OK(Put("0", "0")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("a", "b")); ASSERT_OK(Put("c", "d")); ASSERT_OK(Put("e", "f")); @@ -377,6 +377,8 @@ TEST_P(DBIteratorTest, IterEmpty) { iter->SeekForPrev("foo"); ASSERT_EQ(IterStatus(iter), "(invalid)"); + ASSERT_OK(iter->status()); + delete iter; } while (ChangeCompactOptions()); } @@ -783,18 +785,18 @@ TEST_P(DBIteratorTest, IterWithSnapshot) { TEST_P(DBIteratorTest, IteratorPinsRef) { do { CreateAndReopenWithCF({"pikachu"}, CurrentOptions()); - Put(1, "foo", "hello"); + ASSERT_OK(Put(1, "foo", "hello")); // Get iterator that will yield the current contents of the DB. Iterator* iter = NewIterator(ReadOptions(), handles_[1]); // Write to force compactions - Put(1, "foo", "newvalue1"); + ASSERT_OK(Put(1, "foo", "newvalue1")); for (int i = 0; i < 100; i++) { // 100K values ASSERT_OK(Put(1, Key(i), Key(i) + std::string(100000, 'v'))); } - Put(1, "foo", "newvalue2"); + ASSERT_OK(Put(1, "foo", "newvalue2")); iter->SeekToFirst(); ASSERT_TRUE(iter->Valid()); @@ -809,8 +811,8 @@ TEST_P(DBIteratorTest, IteratorPinsRef) { TEST_P(DBIteratorTest, IteratorDeleteAfterCfDelete) { CreateAndReopenWithCF({"pikachu"}, CurrentOptions()); - Put(1, "foo", "delete-cf-then-delete-iter"); - Put(1, "hello", "value2"); + ASSERT_OK(Put(1, "foo", "delete-cf-then-delete-iter")); + ASSERT_OK(Put(1, "hello", "value2")); ColumnFamilyHandle* cf = handles_[1]; ReadOptions ro; @@ -820,7 +822,7 @@ TEST_P(DBIteratorTest, IteratorDeleteAfterCfDelete) { ASSERT_EQ(IterStatus(iter), "foo->delete-cf-then-delete-iter"); // delete CF handle - db_->DestroyColumnFamilyHandle(cf); + EXPECT_OK(db_->DestroyColumnFamilyHandle(cf)); handles_.erase(std::begin(handles_) + 1); // delete Iterator after CF handle is deleted @@ -832,7 +834,7 @@ TEST_P(DBIteratorTest, IteratorDeleteAfterCfDelete) { TEST_P(DBIteratorTest, IteratorDeleteAfterCfDrop) { CreateAndReopenWithCF({"pikachu"}, CurrentOptions()); - Put(1, "foo", "drop-cf-then-delete-iter"); + ASSERT_OK(Put(1, "foo", "drop-cf-then-delete-iter")); ReadOptions ro; ColumnFamilyHandle* cf = handles_[1]; @@ -842,8 +844,8 @@ TEST_P(DBIteratorTest, IteratorDeleteAfterCfDrop) { ASSERT_EQ(IterStatus(iter), "foo->drop-cf-then-delete-iter"); // drop and delete CF - db_->DropColumnFamily(cf); - db_->DestroyColumnFamilyHandle(cf); + EXPECT_OK(db_->DropColumnFamily(cf)); + EXPECT_OK(db_->DestroyColumnFamilyHandle(cf)); handles_.erase(std::begin(handles_) + 1); // delete Iterator after CF handle is dropped @@ -1307,9 +1309,9 @@ TEST_P(DBIteratorTest, PrevAfterAndNextAfterMerge) { // write three entries with different keys using Merge() WriteOptions wopts; - db_->Merge(wopts, "1", "data1"); - db_->Merge(wopts, "2", "data2"); - db_->Merge(wopts, "3", "data3"); + ASSERT_OK(db_->Merge(wopts, "1", "data1")); + ASSERT_OK(db_->Merge(wopts, "2", "data2")); + ASSERT_OK(db_->Merge(wopts, "3", "data3")); std::unique_ptr it(NewIterator(ReadOptions())); @@ -1393,7 +1395,7 @@ class DBIteratorTestForPinnedData : public DBIteratorTest { if (run_config == TestConfig::FLUSH_EVERY_1000) { if (i && i % 1000 == 0) { - Flush(); + ASSERT_OK(Flush()); } } } @@ -1402,7 +1404,7 @@ class DBIteratorTestForPinnedData : public DBIteratorTest { Close(); Reopen(options); } else if (run_config == TestConfig::COMPACT_BEFORE_READ) { - db_->CompactRange(CompactRangeOptions(), nullptr, nullptr); + ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr)); } ReadOptions ro; @@ -1768,6 +1770,7 @@ TEST_P(DBIteratorTest, IterSeekForPrevCrossingFiles) { Iterator* iter = NewIterator(ro); iter->SeekForPrev("c2"); ASSERT_TRUE(!iter->Valid()); + ASSERT_OK(iter->status()); delete iter; } } @@ -1823,6 +1826,7 @@ TEST_P(DBIteratorTest, IterSeekForPrevCrossingFilesCustomPrefixExtractor) { Iterator* iter = NewIterator(ro); iter->SeekForPrev("c2"); ASSERT_TRUE(!iter->Valid()); + ASSERT_OK(iter->status()); delete iter; } } @@ -2151,19 +2155,19 @@ TEST_P(DBIteratorTest, ReadAhead) { std::string value(1024, 'a'); for (int i = 0; i < 100; i++) { - Put(Key(i), value); + ASSERT_OK(Put(Key(i), value)); } ASSERT_OK(Flush()); MoveFilesToLevel(2); for (int i = 0; i < 100; i++) { - Put(Key(i), value); + ASSERT_OK(Put(Key(i), value)); } ASSERT_OK(Flush()); MoveFilesToLevel(1); for (int i = 0; i < 100; i++) { - Put(Key(i), value); + ASSERT_OK(Put(Key(i), value)); } ASSERT_OK(Flush()); #ifndef ROCKSDB_LITE @@ -2270,6 +2274,7 @@ TEST_P(DBIteratorTest, Refresh) { ASSERT_OK(Put("x", "y")); std::unique_ptr iter(NewIterator(ReadOptions())); + ASSERT_OK(iter->status()); iter->Seek(Slice("a")); ASSERT_TRUE(iter->Valid()); ASSERT_EQ(iter->key().compare(Slice("x")), 0); @@ -2284,7 +2289,8 @@ TEST_P(DBIteratorTest, Refresh) { iter->Next(); ASSERT_FALSE(iter->Valid()); - iter->Refresh(); + ASSERT_OK(iter->status()); + ASSERT_OK(iter->Refresh()); iter->Seek(Slice("a")); ASSERT_TRUE(iter->Valid()); @@ -2295,7 +2301,7 @@ TEST_P(DBIteratorTest, Refresh) { iter->Next(); ASSERT_FALSE(iter->Valid()); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("m", "n")); @@ -2308,7 +2314,8 @@ TEST_P(DBIteratorTest, Refresh) { iter->Next(); ASSERT_FALSE(iter->Valid()); - iter->Refresh(); + ASSERT_OK(iter->status()); + ASSERT_OK(iter->Refresh()); iter->Seek(Slice("a")); ASSERT_TRUE(iter->Valid()); @@ -2331,6 +2338,7 @@ TEST_P(DBIteratorTest, RefreshWithSnapshot) { ReadOptions options; options.snapshot = snapshot; Iterator* iter = NewIterator(options); + ASSERT_OK(iter->status()); iter->Seek(Slice("a")); ASSERT_TRUE(iter->Valid()); @@ -2346,8 +2354,8 @@ TEST_P(DBIteratorTest, RefreshWithSnapshot) { iter->Next(); ASSERT_FALSE(iter->Valid()); - Status s; - s = iter->Refresh(); + ASSERT_OK(iter->status()); + Status s = iter->Refresh(); ASSERT_TRUE(s.IsNotSupported()); db_->ReleaseSnapshot(snapshot); delete iter; @@ -2405,14 +2413,14 @@ TEST_P(DBIteratorTest, UpperBoundWithChangeDirection) { TEST_P(DBIteratorTest, TableFilter) { ASSERT_OK(Put("a", "1")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("b", "2")); ASSERT_OK(Put("c", "3")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); ASSERT_OK(Put("d", "4")); ASSERT_OK(Put("e", "5")); ASSERT_OK(Put("f", "6")); - dbfull()->Flush(FlushOptions()); + EXPECT_OK(dbfull()->Flush(FlushOptions())); // Ensure the table_filter callback is called once for each table. { @@ -2597,13 +2605,13 @@ TEST_P(DBIteratorTest, SeekAfterHittingManyInternalKeys) { ReadOptions ropts; ropts.max_skippable_internal_keys = 2; - Put("1", "val_1"); + ASSERT_OK(Put("1", "val_1")); // Add more tombstones than max_skippable_internal_keys so that Next() fails. - Delete("2"); - Delete("3"); - Delete("4"); - Delete("5"); - Put("6", "val_6"); + ASSERT_OK(Delete("2")); + ASSERT_OK(Delete("3")); + ASSERT_OK(Delete("4")); + ASSERT_OK(Delete("5")); + ASSERT_OK(Put("6", "val_6")); std::unique_ptr iter(NewIterator(ropts)); iter->SeekToFirst(); @@ -2645,9 +2653,9 @@ TEST_P(DBIteratorTest, NonBlockingIterationBugRepro) { DestroyAndReopen(options); // Two records in sst file, each in its own block. - Put("b", ""); - Put("d", ""); - Flush(); + ASSERT_OK(Put("b", "")); + ASSERT_OK(Put("d", "")); + ASSERT_OK(Flush()); // Create a nonblocking iterator before writing to memtable. ReadOptions ropt; @@ -2657,7 +2665,7 @@ TEST_P(DBIteratorTest, NonBlockingIterationBugRepro) { // Overwrite a key in memtable many times to hit // max_sequential_skip_in_iterations (which is 8 by default). for (int i = 0; i < 20; ++i) { - Put("c", ""); + ASSERT_OK(Put("c", "")); } // Load the second block in sst file into the block cache. @@ -2674,9 +2682,9 @@ TEST_P(DBIteratorTest, NonBlockingIterationBugRepro) { } TEST_P(DBIteratorTest, SeekBackwardAfterOutOfUpperBound) { - Put("a", ""); - Put("b", ""); - Flush(); + ASSERT_OK(Put("a", "")); + ASSERT_OK(Put("b", "")); + ASSERT_OK(Flush()); ReadOptions ropt; Slice ub = "b"; diff --git a/db/db_memtable_test.cc b/db/db_memtable_test.cc index f2c61aeb7..df1c26ee6 100644 --- a/db/db_memtable_test.cc +++ b/db/db_memtable_test.cc @@ -129,7 +129,6 @@ class TestPrefixExtractor : public SliceTransform { TEST_F(DBMemTableTest, DuplicateSeq) { SequenceNumber seq = 123; std::string value; - Status s; MergeContext merge_context; Options options; InternalKeyComparator ikey_cmp(options.comparator); @@ -162,7 +161,7 @@ TEST_F(DBMemTableTest, DuplicateSeq) { if (!insert_dup) { seq++; } - s = mem->Add(seq, kTypeValue, "foo", "value" + ToString(seq)); + Status s = mem->Add(seq, kTypeValue, "foo", "value" + ToString(seq)); if (insert_dup) { ASSERT_TRUE(s.IsTryAgain()); } else { @@ -200,7 +199,6 @@ TEST_F(DBMemTableTest, DuplicateSeq) { TEST_F(DBMemTableTest, ConcurrentMergeWrite) { int num_ops = 1000; std::string value; - Status s; MergeContext merge_context; Options options; // A merge operator that is not sensitive to concurrent writes since in this @@ -252,6 +250,7 @@ TEST_F(DBMemTableTest, ConcurrentMergeWrite) { LookupKey lkey("key", kMaxSequenceNumber); bool res = mem->Get(lkey, &value, /*timestamp=*/nullptr, &status, &merge_context, &max_covering_tombstone_seq, roptions); + ASSERT_OK(status); ASSERT_TRUE(res); uint64_t ivalue = DecodeFixed64(Slice(value).data()); uint64_t sum = 0; diff --git a/db/db_merge_operand_test.cc b/db/db_merge_operand_test.cc index 7ec256213..e7709c1f4 100644 --- a/db/db_merge_operand_test.cc +++ b/db/db_merge_operand_test.cc @@ -59,29 +59,29 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { merge_operands_info.expected_max_number_of_operands = num_records; // k0 value in memtable - Put("k0", "PutARock"); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k0", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(Put("k0", "PutARock")); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k0", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "PutARock"); // k0.1 value in SST - Put("k0.1", "RockInSST"); + ASSERT_OK(Put("k0.1", "RockInSST")); ASSERT_OK(Flush()); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k0.1", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k0.1", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "RockInSST"); // All k1 values are in memtable. ASSERT_OK(Merge("k1", "a")); - Put("k1", "x"); + ASSERT_OK(Put("k1", "x")); ASSERT_OK(Merge("k1", "b")); ASSERT_OK(Merge("k1", "c")); ASSERT_OK(Merge("k1", "d")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k1", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "x"); ASSERT_EQ(values[1], "b"); ASSERT_EQ(values[2], "c"); @@ -98,13 +98,13 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { // All k1.1 values are in memtable. ASSERT_OK(Merge("k1.1", "r")); - Delete("k1.1"); + ASSERT_OK(Delete("k1.1")); ASSERT_OK(Merge("k1.1", "c")); ASSERT_OK(Merge("k1.1", "k")); ASSERT_OK(Merge("k1.1", "s")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1.1", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k1.1", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "c"); ASSERT_EQ(values[1], "k"); ASSERT_EQ(values[2], "s"); @@ -115,9 +115,9 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { ASSERT_OK(Merge("k2", "e")); ASSERT_OK(Merge("k2", "r")); ASSERT_OK(Flush()); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k2", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "q"); ASSERT_EQ(values[1], "w"); ASSERT_EQ(values[2], "e"); @@ -125,30 +125,30 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { // All k2.1 values are flushed to L0 into a single file. ASSERT_OK(Merge("k2.1", "m")); - Put("k2.1", "l"); + ASSERT_OK(Put("k2.1", "l")); ASSERT_OK(Merge("k2.1", "n")); ASSERT_OK(Merge("k2.1", "o")); ASSERT_OK(Flush()); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2.1", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k2.1", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "l,n,o"); // All k2.2 values are flushed to L0 into a single file. ASSERT_OK(Merge("k2.2", "g")); - Delete("k2.2"); + ASSERT_OK(Delete("k2.2")); ASSERT_OK(Merge("k2.2", "o")); ASSERT_OK(Merge("k2.2", "t")); ASSERT_OK(Flush()); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2.2", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k2.2", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "o,t"); // Do some compaction that will make the following tests more predictable // Slice start("PutARock"); // Slice end("t"); - db_->CompactRange(CompactRangeOptions(), nullptr, nullptr); + ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr)); // All k3 values are flushed and are in different files. ASSERT_OK(Merge("k3", "ab")); @@ -158,9 +158,9 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { ASSERT_OK(Merge("k3", "cd")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3", "de")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k3", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "ab"); ASSERT_EQ(values[1], "bc"); ASSERT_EQ(values[2], "cd"); @@ -169,14 +169,14 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { // All k3.1 values are flushed and are in different files. ASSERT_OK(Merge("k3.1", "ab")); ASSERT_OK(Flush()); - Put("k3.1", "bc"); + ASSERT_OK(Put("k3.1", "bc")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3.1", "cd")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3.1", "de")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3.1", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k3.1", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "bc"); ASSERT_EQ(values[1], "cd"); ASSERT_EQ(values[2], "de"); @@ -184,14 +184,14 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { // All k3.2 values are flushed and are in different files. ASSERT_OK(Merge("k3.2", "ab")); ASSERT_OK(Flush()); - Delete("k3.2"); + ASSERT_OK(Delete("k3.2")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3.2", "cd")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3.2", "de")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3.2", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k3.2", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "cd"); ASSERT_EQ(values[1], "de"); @@ -206,9 +206,9 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { ASSERT_OK(Flush()); MoveFilesToLevel(1); ASSERT_OK(Merge("k4", "ed")); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k4", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k4", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "ba"); ASSERT_EQ(values[1], "cb"); ASSERT_EQ(values[2], "dc"); @@ -219,14 +219,14 @@ TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) { ASSERT_OK(Merge("k5", "am")); ASSERT_OK(Merge("k5", "i")); ASSERT_OK(Flush()); - Put("k5", "remember"); + ASSERT_OK(Put("k5", "remember")); ASSERT_OK(Merge("k5", "i")); ASSERT_OK(Merge("k5", "am")); ASSERT_OK(Merge("k5", "rocks")); - dbfull()->TEST_SwitchMemtable(); - db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k5", - values.data(), &merge_operands_info, - &number_of_operands); + ASSERT_OK(dbfull()->TEST_SwitchMemtable()); + ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), + "k5", values.data(), &merge_operands_info, + &number_of_operands)); ASSERT_EQ(values[0], "remember"); ASSERT_EQ(values[1], "i"); ASSERT_EQ(values[2], "am"); diff --git a/db/db_merge_operator_test.cc b/db/db_merge_operator_test.cc index e8e6f0491..4b819bd62 100644 --- a/db/db_merge_operator_test.cc +++ b/db/db_merge_operator_test.cc @@ -94,7 +94,7 @@ TEST_F(DBMergeOperatorTest, LimitMergeOperands) { ASSERT_OK(Merge("k1", "c")); ASSERT_OK(Merge("k1", "d")); std::string value; - ASSERT_TRUE(db_->Get(ReadOptions(), "k1", &value).ok()); + ASSERT_OK(db_->Get(ReadOptions(), "k1", &value)); // Make sure that only the latest two merge operands are used. If this was // not the case the value would be "a,b,c,d". ASSERT_EQ(value, "c,d"); @@ -105,7 +105,7 @@ TEST_F(DBMergeOperatorTest, LimitMergeOperands) { ASSERT_OK(Merge("k2", "c")); ASSERT_OK(Merge("k2", "d")); ASSERT_OK(Flush()); - ASSERT_TRUE(db_->Get(ReadOptions(), "k2", &value).ok()); + ASSERT_OK(db_->Get(ReadOptions(), "k2", &value)); ASSERT_EQ(value, "c,d"); // All K3 values are flushed and are in different files. @@ -116,7 +116,7 @@ TEST_F(DBMergeOperatorTest, LimitMergeOperands) { ASSERT_OK(Merge("k3", "cd")); ASSERT_OK(Flush()); ASSERT_OK(Merge("k3", "de")); - ASSERT_TRUE(db_->Get(ReadOptions(), "k3", &value).ok()); + ASSERT_OK(db_->Get(ReadOptions(), "k3", &value)); ASSERT_EQ(value, "cd,de"); // All K4 values are in different levels @@ -130,7 +130,7 @@ TEST_F(DBMergeOperatorTest, LimitMergeOperands) { ASSERT_OK(Flush()); MoveFilesToLevel(1); ASSERT_OK(Merge("k4", "de")); - ASSERT_TRUE(db_->Get(ReadOptions(), "k4", &value).ok()); + ASSERT_OK(db_->Get(ReadOptions(), "k4", &value)); ASSERT_EQ(value, "cd,de"); } @@ -344,8 +344,9 @@ TEST_P(MergeOperatorPinningTest, EvictCacheBeforeMerge) { // Code executed before merge operation merge_hook->before_merge_ = [&]() { // Evict all tables from cache before every merge operation + auto* table_cache = dbfull()->TEST_table_cache(); for (uint64_t num : file_numbers) { - TableCache::Evict(dbfull()->TEST_table_cache(), num); + TableCache::Evict(table_cache, num); } // Decrease cache capacity to force all unrefed blocks to be evicted if (bbto.block_cache) { @@ -366,7 +367,7 @@ TEST_P(MergeOperatorPinningTest, EvictCacheBeforeMerge) { VerifyDBFromMap(true_data, &total_reads); ASSERT_EQ(merge_cnt, total_reads); - db_->CompactRange(CompactRangeOptions(), nullptr, nullptr); + ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr)); VerifyDBFromMap(true_data, &total_reads); } @@ -385,7 +386,7 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) { std::function writer_func = [&]() { int k = 0; for (int i = 0; i < kNumWrites; i++) { - db_->Merge(WriteOptions(), Key(k), Key(k)); + ASSERT_OK(db_->Merge(WriteOptions(), Key(k), Key(k))); if (i && i % kNumOperands == 0) { k++; @@ -403,7 +404,7 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) { ReadOptions ro; ro.tailing = true; Iterator* iter = db_->NewIterator(ro); - + ASSERT_OK(iter->status()); iter->SeekToFirst(); for (int i = 0; i < (kNumWrites / kNumOperands); i++) { while (!iter->Valid()) { @@ -416,6 +417,7 @@ TEST_P(MergeOperatorPinningTest, TailingIterator) { iter->Next(); } + ASSERT_OK(iter->status()); delete iter; }; @@ -449,12 +451,13 @@ TEST_F(DBMergeOperatorTest, TailingIteratorMemtableUnrefedBySomeoneElse) { // ForwardIterator to not pin it in some circumstances. This test // reproduces it. - db_->Merge(WriteOptions(), "key", "sst"); - db_->Flush(FlushOptions()); // Switch to SuperVersion A - db_->Merge(WriteOptions(), "key", "memtable"); + ASSERT_OK(db_->Merge(WriteOptions(), "key", "sst")); + ASSERT_OK(db_->Flush(FlushOptions())); // Switch to SuperVersion A + ASSERT_OK(db_->Merge(WriteOptions(), "key", "memtable")); // Pin SuperVersion A std::unique_ptr someone_else(db_->NewIterator(ReadOptions())); + ASSERT_OK(someone_else->status()); bool pushed_first_operand = false; bool stepped_to_next_operand = false; @@ -462,7 +465,7 @@ TEST_F(DBMergeOperatorTest, TailingIteratorMemtableUnrefedBySomeoneElse) { "DBIter::MergeValuesNewToOld:PushedFirstOperand", [&](void*) { EXPECT_FALSE(pushed_first_operand); pushed_first_operand = true; - db_->Flush(FlushOptions()); // Switch to SuperVersion B + EXPECT_OK(db_->Flush(FlushOptions())); // Switch to SuperVersion B }); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack( "DBIter::MergeValuesNewToOld:SteppedToNextOperand", [&](void*) { @@ -477,7 +480,7 @@ TEST_F(DBMergeOperatorTest, TailingIteratorMemtableUnrefedBySomeoneElse) { std::unique_ptr iter(db_->NewIterator(ro)); iter->Seek("key"); - ASSERT_TRUE(iter->status().ok()); + ASSERT_OK(iter->status()); ASSERT_TRUE(iter->Valid()); EXPECT_EQ(std::string("sst,memtable"), iter->value().ToString()); EXPECT_TRUE(pushed_first_operand); diff --git a/db/db_test_util.cc b/db/db_test_util.cc index 8c57db1bf..0b9806bb1 100644 --- a/db/db_test_util.cc +++ b/db/db_test_util.cc @@ -200,28 +200,28 @@ bool DBTestBase::ChangeCompactOptions() { Destroy(last_options_); auto options = CurrentOptions(); options.create_if_missing = true; - TryReopen(options); + Reopen(options); return true; } else if (option_config_ == kUniversalCompaction) { option_config_ = kUniversalCompactionMultiLevel; Destroy(last_options_); auto options = CurrentOptions(); options.create_if_missing = true; - TryReopen(options); + Reopen(options); return true; } else if (option_config_ == kUniversalCompactionMultiLevel) { option_config_ = kLevelSubcompactions; Destroy(last_options_); auto options = CurrentOptions(); assert(options.max_subcompactions > 1); - TryReopen(options); + Reopen(options); return true; } else if (option_config_ == kLevelSubcompactions) { option_config_ = kUniversalSubcompactions; Destroy(last_options_); auto options = CurrentOptions(); assert(options.max_subcompactions > 1); - TryReopen(options); + Reopen(options); return true; } else { return false; @@ -680,7 +680,7 @@ void DBTestBase::Close() { void DBTestBase::DestroyAndReopen(const Options& options) { // Destroy using last options Destroy(last_options_); - ASSERT_OK(TryReopen(options)); + Reopen(options); } void DBTestBase::Destroy(const Options& options, bool delete_cf_paths) { diff --git a/db/forward_iterator.cc b/db/forward_iterator.cc index 013af04e9..b881dffa7 100644 --- a/db/forward_iterator.cc +++ b/db/forward_iterator.cc @@ -46,7 +46,13 @@ class ForwardLevelIterator : public InternalIterator { file_iter_(nullptr), pinned_iters_mgr_(nullptr), prefix_extractor_(prefix_extractor), - allow_unprepared_value_(allow_unprepared_value) {} + allow_unprepared_value_(allow_unprepared_value) { + /* + NOTE needed for ASSERT_STATUS_CHECKED + in MergeOperatorPinningTest/MergeOperatorPinningTest.TailingIterator + */ + status_.PermitUncheckedError(); + } ~ForwardLevelIterator() override { // Reset current pointer diff --git a/db/write_batch_test.cc b/db/write_batch_test.cc index 82ce2e96d..ba73e206c 100644 --- a/db/write_batch_test.cc +++ b/db/write_batch_test.cc @@ -64,6 +64,7 @@ static std::string PrintContents(WriteBatch* b, if (iter == nullptr) { continue; } + EXPECT_OK(iter->status()); for (iter->SeekToFirst(); iter->Valid(); iter->Next()) { ParsedInternalKey ikey; ikey.clear(); @@ -117,6 +118,7 @@ static std::string PrintContents(WriteBatch* b, state.append("@"); state.append(NumberToString(ikey.sequence)); } + EXPECT_OK(iter->status()); } if (s.ok()) { EXPECT_EQ(b->HasPut(), put_count > 0); diff --git a/utilities/write_batch_with_index/write_batch_with_index_test.cc b/utilities/write_batch_with_index/write_batch_with_index_test.cc index ac4ab7af4..dfd16866e 100644 --- a/utilities/write_batch_with_index/write_batch_with_index_test.cc +++ b/utilities/write_batch_with_index/write_batch_with_index_test.cc @@ -96,11 +96,11 @@ void TestValueAsSecondaryIndexHelper(std::vector entries, ColumnFamilyHandleImplDummy index(8, BytewiseComparator()); for (auto& e : entries) { if (e.type == kPutRecord) { - batch->Put(&data, e.key, e.value); - batch->Put(&index, e.value, e.key); + ASSERT_OK(batch->Put(&data, e.key, e.value)); + ASSERT_OK(batch->Put(&index, e.value, e.key)); } else if (e.type == kMergeRecord) { - batch->Merge(&data, e.key, e.value); - batch->Put(&index, e.value, e.key); + ASSERT_OK(batch->Merge(&data, e.key, e.value)); + ASSERT_OK(batch->Put(&index, e.value, e.key)); } else { assert(e.type == kDeleteRecord); std::unique_ptr iter(batch->NewIterator(&data)); @@ -109,8 +109,8 @@ void TestValueAsSecondaryIndexHelper(std::vector entries, auto write_entry = iter->Entry(); ASSERT_EQ(e.key, write_entry.key.ToString()); ASSERT_EQ(e.value, write_entry.value.ToString()); - batch->Delete(&data, e.key); - batch->Put(&index, e.value, ""); + ASSERT_OK(batch->Delete(&data, e.key)); + ASSERT_OK(batch->Put(&index, e.value, "")); } } @@ -243,7 +243,7 @@ void TestValueAsSecondaryIndexHelper(std::vector entries, // Verify WriteBatch can be iterated TestHandler handler; - batch->GetWriteBatch()->Iterate(&handler); + ASSERT_OK(batch->GetWriteBatch()->Iterate(&handler)); // Verify data column family { @@ -315,18 +315,18 @@ TEST_F(WriteBatchWithIndexTest, TestComparatorForCF) { ColumnFamilyHandleImplDummy cf2(88, BytewiseComparator()); WriteBatchWithIndex batch(BytewiseComparator(), 20); - batch.Put(&cf1, "ddd", ""); - batch.Put(&cf2, "aaa", ""); - batch.Put(&cf2, "eee", ""); - batch.Put(&cf1, "ccc", ""); - batch.Put(&reverse_cf, "a11", ""); - batch.Put(&cf1, "bbb", ""); + ASSERT_OK(batch.Put(&cf1, "ddd", "")); + ASSERT_OK(batch.Put(&cf2, "aaa", "")); + ASSERT_OK(batch.Put(&cf2, "eee", "")); + ASSERT_OK(batch.Put(&cf1, "ccc", "")); + ASSERT_OK(batch.Put(&reverse_cf, "a11", "")); + ASSERT_OK(batch.Put(&cf1, "bbb", "")); Slice key_slices[] = {"a", "3", "3"}; Slice value_slice = ""; - batch.Put(&reverse_cf, SliceParts(key_slices, 3), - SliceParts(&value_slice, 1)); - batch.Put(&reverse_cf, "a22", ""); + ASSERT_OK(batch.Put(&reverse_cf, SliceParts(key_slices, 3), + SliceParts(&value_slice, 1))); + ASSERT_OK(batch.Put(&reverse_cf, "a22", "")); { std::unique_ptr iter(batch.NewIterator(&cf1)); @@ -402,20 +402,20 @@ TEST_F(WriteBatchWithIndexTest, TestOverwriteKey) { ColumnFamilyHandleImplDummy cf2(88, BytewiseComparator()); WriteBatchWithIndex batch(BytewiseComparator(), 20, true); - batch.Put(&cf1, "ddd", ""); - batch.Merge(&cf1, "ddd", ""); - batch.Delete(&cf1, "ddd"); - batch.Put(&cf2, "aaa", ""); - batch.Delete(&cf2, "aaa"); - batch.Put(&cf2, "aaa", "aaa"); - batch.Put(&cf2, "eee", "eee"); - batch.Put(&cf1, "ccc", ""); - batch.Put(&reverse_cf, "a11", ""); - batch.Delete(&cf1, "ccc"); - batch.Put(&reverse_cf, "a33", "a33"); - batch.Put(&reverse_cf, "a11", "a11"); + ASSERT_OK(batch.Put(&cf1, "ddd", "")); + ASSERT_OK(batch.Merge(&cf1, "ddd", "")); + ASSERT_OK(batch.Delete(&cf1, "ddd")); + ASSERT_OK(batch.Put(&cf2, "aaa", "")); + ASSERT_OK(batch.Delete(&cf2, "aaa")); + ASSERT_OK(batch.Put(&cf2, "aaa", "aaa")); + ASSERT_OK(batch.Put(&cf2, "eee", "eee")); + ASSERT_OK(batch.Put(&cf1, "ccc", "")); + ASSERT_OK(batch.Put(&reverse_cf, "a11", "")); + ASSERT_OK(batch.Delete(&cf1, "ccc")); + ASSERT_OK(batch.Put(&reverse_cf, "a33", "a33")); + ASSERT_OK(batch.Put(&reverse_cf, "a11", "a11")); Slice slices[] = {"a", "3", "3"}; - batch.Delete(&reverse_cf, SliceParts(slices, 3)); + ASSERT_OK(batch.Delete(&reverse_cf, SliceParts(slices, 3))); { std::unique_ptr iter(batch.NewIterator(&cf1)); @@ -570,10 +570,10 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) { WriteBatchWithIndex batch(BytewiseComparator(), 20, true); if (rand_seed % 2 == 0) { - batch.Put(&cf2, "zoo", "bar"); + ASSERT_OK(batch.Put(&cf2, "zoo", "bar")); } if (rand_seed % 4 == 1) { - batch.Put(&cf3, "zoo", "bar"); + ASSERT_OK(batch.Put(&cf3, "zoo", "bar")); } KVMap map; @@ -589,24 +589,24 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) { break; case 1: // only delta has it - batch.Put(&cf1, key, value); + ASSERT_OK(batch.Put(&cf1, key, value)); map[key] = value; merged_map[key] = value; break; case 2: // both has it. Delta should win - batch.Put(&cf1, key, value); + ASSERT_OK(batch.Put(&cf1, key, value)); map[key] = "wrong_value"; merged_map[key] = value; break; case 3: // both has it. Delta is delete - batch.Delete(&cf1, key); + ASSERT_OK(batch.Delete(&cf1, key)); map[key] = "wrong_value"; break; case 4: // only delta has it. Delta is delete - batch.Delete(&cf1, key); + ASSERT_OK(batch.Delete(&cf1, key)); map[key] = "wrong_value"; break; default: @@ -675,6 +675,8 @@ TEST_F(WriteBatchWithIndexTest, TestRandomIteraratorWithBase) { AssertItersEqual(iter.get(), result_iter.get()); is_valid = iter->Valid(); } + + ASSERT_OK(iter->status()); } } @@ -722,8 +724,8 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) { } // Test the case that there is one element in the write batch - batch.Put(&cf2, "zoo", "bar"); - batch.Put(&cf1, "a", "aa"); + ASSERT_OK(batch.Put(&cf2, "zoo", "bar")); + ASSERT_OK(batch.Put(&cf1, "a", "aa")); { KVMap empty_map; std::unique_ptr iter( @@ -736,10 +738,10 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBase) { ASSERT_TRUE(!iter->Valid()); } - batch.Delete(&cf1, "b"); - batch.Put(&cf1, "c", "cc"); - batch.Put(&cf1, "d", "dd"); - batch.Delete(&cf1, "e"); + ASSERT_OK(batch.Delete(&cf1, "b")); + ASSERT_OK(batch.Put(&cf1, "c", "cc")); + ASSERT_OK(batch.Put(&cf1, "d", "dd")); + ASSERT_OK(batch.Delete(&cf1, "e")); { KVMap map; @@ -847,8 +849,8 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) { WriteBatchWithIndex batch(BytewiseComparator(), 20, true); // Test the case that there is one element in the write batch - batch.Put(&cf2, "zoo", "bar"); - batch.Put(&cf1, "a", "aa"); + ASSERT_OK(batch.Put(&cf2, "zoo", "bar")); + ASSERT_OK(batch.Put(&cf1, "a", "aa")); { KVMap empty_map; std::unique_ptr iter( @@ -861,7 +863,7 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) { ASSERT_TRUE(!iter->Valid()); } - batch.Put(&cf1, "c", "cc"); + ASSERT_OK(batch.Put(&cf1, "c", "cc")); { KVMap map; std::unique_ptr iter( @@ -894,7 +896,7 @@ TEST_F(WriteBatchWithIndexTest, TestIteraratorWithBaseReverseCmp) { } // default column family - batch.Put("a", "b"); + ASSERT_OK(batch.Put("a", "b")); { KVMap map; map["b"] = ""; @@ -936,14 +938,14 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatch) { s = batch.GetFromBatch(options, "b", &value); ASSERT_TRUE(s.IsNotFound()); - batch.Put("a", "a"); - batch.Put("b", "b"); - batch.Put("c", "c"); - batch.Put("a", "z"); - batch.Delete("c"); - batch.Delete("d"); - batch.Delete("e"); - batch.Put("e", "e"); + ASSERT_OK(batch.Put("a", "a")); + ASSERT_OK(batch.Put("b", "b")); + ASSERT_OK(batch.Put("c", "c")); + ASSERT_OK(batch.Put("a", "z")); + ASSERT_OK(batch.Delete("c")); + ASSERT_OK(batch.Delete("d")); + ASSERT_OK(batch.Delete("e")); + ASSERT_OK(batch.Put("e", "e")); s = batch.GetFromBatch(options, "b", &value); ASSERT_OK(s); @@ -966,7 +968,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatch) { ASSERT_OK(s); ASSERT_EQ("e", value); - batch.Merge("z", "z"); + ASSERT_OK(batch.Merge("z", "z")); s = batch.GetFromBatch(options, "z", &value); ASSERT_NOK(s); // No merge operator specified. @@ -984,7 +986,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge) { std::string dbname = test::PerThreadDBPath("write_batch_with_index_test"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); ASSERT_OK(s); @@ -995,18 +997,18 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge) { s = batch.GetFromBatch(options, "x", &value); ASSERT_TRUE(s.IsNotFound()); - batch.Put("x", "X"); + ASSERT_OK(batch.Put("x", "X")); std::string expected = "X"; for (int i = 0; i < 5; i++) { - batch.Merge("x", ToString(i)); + ASSERT_OK(batch.Merge("x", ToString(i))); expected = expected + "," + ToString(i); if (i % 2 == 0) { - batch.Put("y", ToString(i / 2)); + ASSERT_OK(batch.Put("y", ToString(i / 2))); } - batch.Merge("z", "z"); + ASSERT_OK(batch.Merge("z", "z")); s = batch.GetFromBatch(column_family, options, "x", &value); ASSERT_OK(s); @@ -1021,7 +1023,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge) { } delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge2) { @@ -1032,7 +1034,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge2) { std::string dbname = test::PerThreadDBPath("write_batch_with_index_test"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); ASSERT_OK(s); @@ -1045,43 +1047,43 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchMerge2) { s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsNotFound()); - batch.Put(column_family, "X", "x"); + ASSERT_OK(batch.Put(column_family, "X", "x")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_OK(s); ASSERT_EQ("x", value); - batch.Put(column_family, "X", "x2"); + ASSERT_OK(batch.Put(column_family, "X", "x2")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_OK(s); ASSERT_EQ("x2", value); - batch.Merge(column_family, "X", "aaa"); + ASSERT_OK(batch.Merge(column_family, "X", "aaa")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsMergeInProgress()); - batch.Merge(column_family, "X", "bbb"); + ASSERT_OK(batch.Merge(column_family, "X", "bbb")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsMergeInProgress()); - batch.Put(column_family, "X", "x3"); + ASSERT_OK(batch.Put(column_family, "X", "x3")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_OK(s); ASSERT_EQ("x3", value); - batch.Merge(column_family, "X", "ccc"); + ASSERT_OK(batch.Merge(column_family, "X", "ccc")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsMergeInProgress()); - batch.Delete(column_family, "X"); + ASSERT_OK(batch.Delete(column_family, "X")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsNotFound()); - batch.Merge(column_family, "X", "ddd"); + ASSERT_OK(batch.Merge(column_family, "X", "ddd")); s = batch.GetFromBatch(column_family, options, "X", &value); ASSERT_TRUE(s.IsMergeInProgress()); delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDB) { @@ -1090,7 +1092,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDB) { options.create_if_missing = true; std::string dbname = test::PerThreadDBPath("write_batch_with_index_test"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); ASSERT_OK(s); @@ -1108,8 +1110,8 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDB) { s = db->Put(write_options, "c", "c"); ASSERT_OK(s); - batch.Put("a", "batch.a"); - batch.Delete("b"); + ASSERT_OK(batch.Put("a", "batch.a")); + ASSERT_OK(batch.Delete("b")); s = batch.GetFromBatchAndDB(db, read_options, "a", &value); ASSERT_OK(s); @@ -1125,13 +1127,13 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDB) { s = batch.GetFromBatchAndDB(db, read_options, "x", &value); ASSERT_TRUE(s.IsNotFound()); - db->Delete(write_options, "x"); + ASSERT_OK(db->Delete(write_options, "x")); s = batch.GetFromBatchAndDB(db, read_options, "x", &value); ASSERT_TRUE(s.IsNotFound()); delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) { @@ -1143,9 +1145,9 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) { options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); - assert(s.ok()); + ASSERT_OK(s); WriteBatchWithIndex batch; ReadOptions read_options; @@ -1167,11 +1169,11 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) { s = db->Merge(write_options, "d", "d0"); ASSERT_OK(s); - batch.Merge("a", "a1"); - batch.Merge("a", "a2"); - batch.Merge("b", "b2"); - batch.Merge("d", "d1"); - batch.Merge("e", "e0"); + ASSERT_OK(batch.Merge("a", "a1")); + ASSERT_OK(batch.Merge("a", "a2")); + ASSERT_OK(batch.Merge("b", "b2")); + ASSERT_OK(batch.Merge("d", "d1")); + ASSERT_OK(batch.Merge("e", "e0")); s = batch.GetFromBatchAndDB(db, read_options, "a", &value); ASSERT_OK(s); @@ -1214,7 +1216,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) { ASSERT_OK(s); ASSERT_EQ("a0,a1,a2", value); - batch.Delete("a"); + ASSERT_OK(batch.Delete("a")); s = batch.GetFromBatchAndDB(db, read_options, "a", &value); ASSERT_TRUE(s.IsNotFound()); @@ -1257,7 +1259,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge) { db->ReleaseSnapshot(snapshot); delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge2) { @@ -1269,9 +1271,9 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge2) { options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); - assert(s.ok()); + ASSERT_OK(s); // Test batch with overwrite_key=true WriteBatchWithIndex batch(BytewiseComparator(), 0, true); @@ -1283,12 +1285,12 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge2) { s = batch.GetFromBatchAndDB(db, read_options, "A", &value); ASSERT_TRUE(s.IsNotFound()); - batch.Merge("A", "xxx"); + ASSERT_OK(batch.Merge("A", "xxx")); s = batch.GetFromBatchAndDB(db, read_options, "A", &value); ASSERT_TRUE(s.IsMergeInProgress()); - batch.Merge("A", "yyy"); + ASSERT_OK(batch.Merge("A", "yyy")); s = batch.GetFromBatchAndDB(db, read_options, "A", &value); ASSERT_TRUE(s.IsMergeInProgress()); @@ -1299,13 +1301,13 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge2) { s = batch.GetFromBatchAndDB(db, read_options, "A", &value); ASSERT_TRUE(s.IsMergeInProgress()); - batch.Delete("A"); + ASSERT_OK(batch.Delete("A")); s = batch.GetFromBatchAndDB(db, read_options, "A", &value); ASSERT_TRUE(s.IsNotFound()); delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge3) { @@ -1317,9 +1319,9 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge3) { options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); Status s = DB::Open(options, dbname, &db); - assert(s.ok()); + ASSERT_OK(s); ReadOptions read_options; WriteOptions write_options; @@ -1336,7 +1338,7 @@ TEST_F(WriteBatchWithIndexTest, TestGetFromBatchAndDBMerge3) { ASSERT_EQ(value, "1,2"); delete db; - DestroyDB(dbname, options); + EXPECT_OK(DestroyDB(dbname, options)); } void AssertKey(std::string key, WBWIIterator* iter) { @@ -1354,7 +1356,7 @@ void AssertValue(std::string value, WBWIIterator* iter) { TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingCorrectnessTest) { WriteBatchWithIndex batch(BytewiseComparator(), 0, true); for (char c = 'a'; c <= 'z'; ++c) { - batch.Put(std::string(1, c), std::string(1, c)); + ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c))); } std::unique_ptr iter(batch.NewIterator()); @@ -1362,14 +1364,14 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingCorrectnessTest) { AssertKey("k", iter.get()); iter->Next(); AssertKey("l", iter.get()); - batch.Put("ab", "cc"); + ASSERT_OK(batch.Put("ab", "cc")); iter->Next(); AssertKey("m", iter.get()); - batch.Put("mm", "kk"); + ASSERT_OK(batch.Put("mm", "kk")); iter->Next(); AssertKey("mm", iter.get()); AssertValue("kk", iter.get()); - batch.Delete("mm"); + ASSERT_OK(batch.Delete("mm")); iter->Next(); AssertKey("n", iter.get()); @@ -1379,7 +1381,7 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingCorrectnessTest) { iter->Seek("ab"); AssertKey("ab", iter.get()); - batch.Delete("x"); + ASSERT_OK(batch.Delete("x")); iter->Seek("x"); AssertKey("x", iter.get()); ASSERT_EQ(kDeleteRecord, iter->Entry().type); @@ -1401,7 +1403,7 @@ void AssertIterValue(std::string value, Iterator* iter) { TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) { WriteBatchWithIndex batch(BytewiseComparator(), 0, true); for (char c = 'a'; c <= 'z'; ++c) { - batch.Put(std::string(1, c), std::string(1, c)); + ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c))); } KVMap map; @@ -1416,14 +1418,14 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) { AssertIterKey("k", iter.get()); iter->Next(); AssertIterKey("l", iter.get()); - batch.Put("ab", "cc"); + ASSERT_OK(batch.Put("ab", "cc")); iter->Next(); AssertIterKey("m", iter.get()); - batch.Put("mm", "kk"); + ASSERT_OK(batch.Put("mm", "kk")); iter->Next(); AssertIterKey("mm", iter.get()); AssertIterValue("kk", iter.get()); - batch.Delete("mm"); + ASSERT_OK(batch.Delete("mm")); iter->Next(); AssertIterKey("n", iter.get()); iter->Prev(); @@ -1436,13 +1438,13 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) { AssertIterKey("aa", iter.get()); iter->Prev(); AssertIterKey("a", iter.get()); - batch.Delete("aa"); + ASSERT_OK(batch.Delete("aa")); iter->Next(); AssertIterKey("ab", iter.get()); iter->Prev(); AssertIterKey("a", iter.get()); - batch.Delete("x"); + ASSERT_OK(batch.Delete("x")); iter->Seek("x"); AssertIterKey("y", iter.get()); iter->Next(); @@ -1451,11 +1453,11 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) { iter->Prev(); AssertIterKey("w", iter.get()); - batch.Delete("e"); + ASSERT_OK(batch.Delete("e")); iter->Seek("e"); AssertIterKey("ee", iter.get()); AssertIterValue("ee", iter.get()); - batch.Put("ee", "xx"); + ASSERT_OK(batch.Put("ee", "xx")); // still the same value AssertIterValue("ee", iter.get()); iter->Next(); @@ -1463,13 +1465,15 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseCorrectnessTest) { iter->Prev(); // new value AssertIterValue("xx", iter.get()); + + ASSERT_OK(iter->status()); } // stress testing mutations with IteratorWithBase TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) { WriteBatchWithIndex batch(BytewiseComparator(), 0, true); for (char c = 'a'; c <= 'z'; ++c) { - batch.Put(std::string(1, c), std::string(1, c)); + ASSERT_OK(batch.Put(std::string(1, c), std::string(1, c))); } KVMap map; @@ -1486,16 +1490,16 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) { char c = static_cast(rnd.Uniform(26) + 'a'); switch (random) { case 0: - batch.Put(std::string(1, c), "xxx"); + ASSERT_OK(batch.Put(std::string(1, c), "xxx")); break; case 1: - batch.Put(std::string(2, c), "xxx"); + ASSERT_OK(batch.Put(std::string(2, c), "xxx")); break; case 2: - batch.Delete(std::string(1, c)); + ASSERT_OK(batch.Delete(std::string(1, c))); break; case 3: - batch.Delete(std::string(2, c)); + ASSERT_OK(batch.Delete(std::string(2, c))); break; case 4: iter->Seek(std::string(1, c)); @@ -1517,12 +1521,12 @@ TEST_F(WriteBatchWithIndexTest, MutateWhileIteratingBaseStressTest) { assert(false); } } + ASSERT_OK(iter->status()); } -static std::string PrintContents(WriteBatchWithIndex* batch, - ColumnFamilyHandle* column_family) { - std::string result; - +static void PrintContents(WriteBatchWithIndex* batch, + ColumnFamilyHandle* column_family, + std::string* result) { WBWIIterator* iter; if (column_family == nullptr) { iter = batch->NewIterator(); @@ -1532,41 +1536,50 @@ static std::string PrintContents(WriteBatchWithIndex* batch, iter->SeekToFirst(); while (iter->Valid()) { + ASSERT_OK(iter->status()); + WriteEntry e = iter->Entry(); if (e.type == kPutRecord) { - result.append("PUT("); - result.append(e.key.ToString()); - result.append("):"); - result.append(e.value.ToString()); + result->append("PUT("); + result->append(e.key.ToString()); + result->append("):"); + result->append(e.value.ToString()); } else if (e.type == kMergeRecord) { - result.append("MERGE("); - result.append(e.key.ToString()); - result.append("):"); - result.append(e.value.ToString()); + result->append("MERGE("); + result->append(e.key.ToString()); + result->append("):"); + result->append(e.value.ToString()); } else if (e.type == kSingleDeleteRecord) { - result.append("SINGLE-DEL("); - result.append(e.key.ToString()); - result.append(")"); + result->append("SINGLE-DEL("); + result->append(e.key.ToString()); + result->append(")"); } else { assert(e.type == kDeleteRecord); - result.append("DEL("); - result.append(e.key.ToString()); - result.append(")"); + result->append("DEL("); + result->append(e.key.ToString()); + result->append(")"); } - result.append(","); + result->append(","); iter->Next(); } + ASSERT_OK(iter->status()); + delete iter; - return result; } -static std::string PrintContents(WriteBatchWithIndex* batch, KVMap* base_map, +static std::string PrintContents(WriteBatchWithIndex* batch, ColumnFamilyHandle* column_family) { std::string result; + PrintContents(batch, column_family, &result); + return result; +} +static void PrintContents(WriteBatchWithIndex* batch, KVMap* base_map, + ColumnFamilyHandle* column_family, + std::string* result) { Iterator* iter; if (column_family == nullptr) { iter = batch->NewIteratorWithBase(new KVIter(base_map)); @@ -1576,20 +1589,28 @@ static std::string PrintContents(WriteBatchWithIndex* batch, KVMap* base_map, iter->SeekToFirst(); while (iter->Valid()) { - assert(iter->status().ok()); + ASSERT_OK(iter->status()); Slice key = iter->key(); Slice value = iter->value(); - result.append(key.ToString()); - result.append(":"); - result.append(value.ToString()); - result.append(","); + result->append(key.ToString()); + result->append(":"); + result->append(value.ToString()); + result->append(","); iter->Next(); } + ASSERT_OK(iter->status()); + delete iter; +} + +static std::string PrintContents(WriteBatchWithIndex* batch, KVMap* base_map, + ColumnFamilyHandle* column_family) { + std::string result; + PrintContents(batch, base_map, column_family, &result); return result; } @@ -1598,34 +1619,34 @@ TEST_F(WriteBatchWithIndexTest, SavePointTest) { ColumnFamilyHandleImplDummy cf1(1, BytewiseComparator()); Status s; - batch.Put("A", "a"); - batch.Put("B", "b"); - batch.Put("A", "aa"); - batch.Put(&cf1, "A", "a1"); - batch.Delete(&cf1, "B"); - batch.Put(&cf1, "C", "c1"); - batch.Put(&cf1, "E", "e1"); + ASSERT_OK(batch.Put("A", "a")); + ASSERT_OK(batch.Put("B", "b")); + ASSERT_OK(batch.Put("A", "aa")); + ASSERT_OK(batch.Put(&cf1, "A", "a1")); + ASSERT_OK(batch.Delete(&cf1, "B")); + ASSERT_OK(batch.Put(&cf1, "C", "c1")); + ASSERT_OK(batch.Put(&cf1, "E", "e1")); batch.SetSavePoint(); // 1 - batch.Put("C", "cc"); - batch.Put("B", "bb"); - batch.Delete("A"); - batch.Put(&cf1, "B", "b1"); - batch.Delete(&cf1, "A"); - batch.SingleDelete(&cf1, "E"); + ASSERT_OK(batch.Put("C", "cc")); + ASSERT_OK(batch.Put("B", "bb")); + ASSERT_OK(batch.Delete("A")); + ASSERT_OK(batch.Put(&cf1, "B", "b1")); + ASSERT_OK(batch.Delete(&cf1, "A")); + ASSERT_OK(batch.SingleDelete(&cf1, "E")); batch.SetSavePoint(); // 2 - batch.Put("A", "aaa"); - batch.Put("A", "xxx"); - batch.Delete("B"); - batch.Put(&cf1, "B", "b2"); - batch.Delete(&cf1, "C"); + ASSERT_OK(batch.Put("A", "aaa")); + ASSERT_OK(batch.Put("A", "xxx")); + ASSERT_OK(batch.Delete("B")); + ASSERT_OK(batch.Put(&cf1, "B", "b2")); + ASSERT_OK(batch.Delete(&cf1, "C")); batch.SetSavePoint(); // 3 batch.SetSavePoint(); // 4 - batch.SingleDelete("D"); - batch.Delete(&cf1, "D"); - batch.Delete(&cf1, "E"); + ASSERT_OK(batch.SingleDelete("D")); + ASSERT_OK(batch.Delete(&cf1, "D")); + ASSERT_OK(batch.Delete(&cf1, "E")); ASSERT_EQ( "PUT(A):a,PUT(A):aa,DEL(A),PUT(A):aaa,PUT(A):xxx,PUT(B):b,PUT(B):bb,DEL(" @@ -1672,7 +1693,7 @@ TEST_F(WriteBatchWithIndexTest, SavePointTest) { PrintContents(&batch, &cf1)); batch.SetSavePoint(); // 5 - batch.Put("X", "x"); + ASSERT_OK(batch.Put("X", "x")); ASSERT_EQ("PUT(A):a,PUT(A):aa,DEL(A),PUT(B):b,PUT(B):bb,PUT(C):cc,PUT(X):x,", PrintContents(&batch, nullptr)); @@ -1715,7 +1736,7 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) { std::string value; DBOptions db_options; - batch.SingleDelete("A"); + ASSERT_OK(batch.SingleDelete("A")); s = batch.GetFromBatch(db_options, "A", &value); ASSERT_TRUE(s.IsNotFound()); @@ -1725,10 +1746,10 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) { ASSERT_EQ("SINGLE-DEL(A),", value); batch.Clear(); - batch.Put("A", "a"); - batch.Put("A", "a2"); - batch.Put("B", "b"); - batch.SingleDelete("A"); + ASSERT_OK(batch.Put("A", "a")); + ASSERT_OK(batch.Put("A", "a2")); + ASSERT_OK(batch.Put("B", "b")); + ASSERT_OK(batch.SingleDelete("A")); s = batch.GetFromBatch(db_options, "A", &value); ASSERT_TRUE(s.IsNotFound()); @@ -1739,11 +1760,11 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) { value = PrintContents(&batch, nullptr); ASSERT_EQ("PUT(A):a,PUT(A):a2,SINGLE-DEL(A),PUT(B):b,", value); - batch.Put("C", "c"); - batch.Put("A", "a3"); - batch.Delete("B"); - batch.SingleDelete("B"); - batch.SingleDelete("C"); + ASSERT_OK(batch.Put("C", "c")); + ASSERT_OK(batch.Put("A", "a3")); + ASSERT_OK(batch.Delete("B")); + ASSERT_OK(batch.SingleDelete("B")); + ASSERT_OK(batch.SingleDelete("C")); s = batch.GetFromBatch(db_options, "A", &value); ASSERT_OK(s); @@ -1761,12 +1782,12 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) { ",PUT(C):c,SINGLE-DEL(C),", value); - batch.Put("B", "b4"); - batch.Put("C", "c4"); - batch.Put("D", "d4"); - batch.SingleDelete("D"); - batch.SingleDelete("D"); - batch.Delete("A"); + ASSERT_OK(batch.Put("B", "b4")); + ASSERT_OK(batch.Put("C", "c4")); + ASSERT_OK(batch.Put("D", "d4")); + ASSERT_OK(batch.SingleDelete("D")); + ASSERT_OK(batch.SingleDelete("D")); + ASSERT_OK(batch.Delete("A")); s = batch.GetFromBatch(db_options, "A", &value); ASSERT_TRUE(s.IsNotFound()); @@ -1788,15 +1809,15 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteTest) { } TEST_F(WriteBatchWithIndexTest, SingleDeleteDeltaIterTest) { - Status s; std::string value; DBOptions db_options; WriteBatchWithIndex batch(BytewiseComparator(), 20, true /* overwrite_key */); - batch.Put("A", "a"); - batch.Put("A", "a2"); - batch.Put("B", "b"); - batch.SingleDelete("A"); - batch.Delete("B"); + + ASSERT_OK(batch.Put("A", "a")); + ASSERT_OK(batch.Put("A", "a2")); + ASSERT_OK(batch.Put("B", "b")); + ASSERT_OK(batch.SingleDelete("A")); + ASSERT_OK(batch.Delete("B")); KVMap map; value = PrintContents(&batch, &map, nullptr); @@ -1806,20 +1827,20 @@ TEST_F(WriteBatchWithIndexTest, SingleDeleteDeltaIterTest) { map["C"] = "cc"; map["D"] = "dd"; - batch.SingleDelete("B"); - batch.SingleDelete("C"); - batch.SingleDelete("Z"); + ASSERT_OK(batch.SingleDelete("B")); + ASSERT_OK(batch.SingleDelete("C")); + ASSERT_OK(batch.SingleDelete("Z")); value = PrintContents(&batch, &map, nullptr); ASSERT_EQ("D:dd,", value); - batch.Put("A", "a3"); - batch.Put("B", "b3"); - batch.SingleDelete("A"); - batch.SingleDelete("A"); - batch.SingleDelete("D"); - batch.SingleDelete("D"); - batch.Delete("D"); + ASSERT_OK(batch.Put("A", "a3")); + ASSERT_OK(batch.Put("B", "b3")); + ASSERT_OK(batch.SingleDelete("A")); + ASSERT_OK(batch.SingleDelete("A")); + ASSERT_OK(batch.SingleDelete("D")); + ASSERT_OK(batch.SingleDelete("D")); + ASSERT_OK(batch.Delete("D")); map["E"] = "ee";