update sources to ceph Nautilus 14.2.1

[ceph.git] / ceph / src / rocksdb / utilities / transactions / optimistic_transaction_test.cc

diff --git a/ceph/src/rocksdb/utilities/transactions/optimistic_transaction_test.cc b/ceph/src/rocksdb/utilities/transactions/optimistic_transaction_test.cc
index ce01ef054882a3a3d7c48681e648d8cce80b6879..2c196d43be954a7041d594e180d6717202293f7a 100644 (file)
--- a/ceph/src/rocksdb/utilities/transactions/optimistic_transaction_test.cc
+++ b/ceph/src/rocksdb/utilities/transactions/optimistic_transaction_test.cc
@@ -1,7 +1,7 @@
 //  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under the BSD-style license found in the
-//  LICENSE file in the root directory of this source tree. An additional grant
-//  of patent rights can be found in the PATENTS file in the same directory.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
 
 #ifndef ROCKSDB_LITE
 
@@ -26,14 +26,13 @@ namespace rocksdb {
 class OptimisticTransactionTest : public testing::Test {
  public:
   OptimisticTransactionDB* txn_db;
-  DB* db;
   string dbname;
   Options options;
 
   OptimisticTransactionTest() {
     options.create_if_missing = true;
     options.max_write_buffer_number = 2;
-    dbname = test::TmpDir() + "/optimistic_transaction_testdb";
+    dbname = test::PerThreadDBPath("optimistic_transaction_testdb");
 
     DestroyDB(dbname, options);
     Open();
@@ -45,6 +44,7 @@ class OptimisticTransactionTest : public testing::Test {
 
   void Reopen() {
     delete txn_db;
+    txn_db = nullptr;
     Open();
   }
 
@@ -52,7 +52,7 @@ private:
   void Open() {
     Status s = OptimisticTransactionDB::Open(options, dbname, &txn_db);
     assert(s.ok());
-    db = txn_db->GetBaseDB();
+    assert(txn_db != nullptr);
   }
 };
 
@@ -62,8 +62,8 @@ TEST_F(OptimisticTransactionTest, SuccessTest) {
   string value;
   Status s;
 
-  db->Put(write_options, Slice("foo"), Slice("bar"));
-  db->Put(write_options, Slice("foo2"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo2"), Slice("bar"));
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
@@ -79,7 +79,7 @@ TEST_F(OptimisticTransactionTest, SuccessTest) {
   s = txn->Commit();
   ASSERT_OK(s);
 
-  db->Get(read_options, "foo", &value);
+  txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "bar2");
 
   delete txn;
@@ -91,8 +91,8 @@ TEST_F(OptimisticTransactionTest, WriteConflictTest) {
   string value;
   Status s;
 
-  db->Put(write_options, "foo", "bar");
-  db->Put(write_options, "foo2", "bar");
+  txn_db->Put(write_options, "foo", "bar");
+  txn_db->Put(write_options, "foo2", "bar");
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
@@ -100,10 +100,10 @@ TEST_F(OptimisticTransactionTest, WriteConflictTest) {
   txn->Put("foo", "bar2");
 
   // This Put outside of a transaction will conflict with the previous write
-  s = db->Put(write_options, "foo", "barz");
+  s = txn_db->Put(write_options, "foo", "barz");
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "foo", &value);
+  s = txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "barz");
   ASSERT_EQ(1, txn->GetNumKeys());
 
@@ -111,9 +111,9 @@ TEST_F(OptimisticTransactionTest, WriteConflictTest) {
   ASSERT_TRUE(s.IsBusy());  // Txn should not commit
 
   // Verify that transaction did not write anything
-  db->Get(read_options, "foo", &value);
+  txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "barz");
-  db->Get(read_options, "foo2", &value);
+  txn_db->Get(read_options, "foo2", &value);
   ASSERT_EQ(value, "bar");
 
   delete txn;
@@ -126,29 +126,29 @@ TEST_F(OptimisticTransactionTest, WriteConflictTest2) {
   string value;
   Status s;
 
-  db->Put(write_options, "foo", "bar");
-  db->Put(write_options, "foo2", "bar");
+  txn_db->Put(write_options, "foo", "bar");
+  txn_db->Put(write_options, "foo2", "bar");
 
   txn_options.set_snapshot = true;
   Transaction* txn = txn_db->BeginTransaction(write_options, txn_options);
   ASSERT_TRUE(txn);
 
   // This Put outside of a transaction will conflict with a later write
-  s = db->Put(write_options, "foo", "barz");
+  s = txn_db->Put(write_options, "foo", "barz");
   ASSERT_OK(s);
 
   txn->Put("foo", "bar2");  // Conflicts with write done after snapshot taken
 
-  s = db->Get(read_options, "foo", &value);
+  s = txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "barz");
 
   s = txn->Commit();
   ASSERT_TRUE(s.IsBusy());  // Txn should not commit
 
   // Verify that transaction did not write anything
-  db->Get(read_options, "foo", &value);
+  txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "barz");
-  db->Get(read_options, "foo2", &value);
+  txn_db->Get(read_options, "foo2", &value);
   ASSERT_EQ(value, "bar");
 
   delete txn;
@@ -161,8 +161,8 @@ TEST_F(OptimisticTransactionTest, ReadConflictTest) {
   string value;
   Status s;
 
-  db->Put(write_options, "foo", "bar");
-  db->Put(write_options, "foo2", "bar");
+  txn_db->Put(write_options, "foo", "bar");
+  txn_db->Put(write_options, "foo2", "bar");
 
   txn_options.set_snapshot = true;
   Transaction* txn = txn_db->BeginTransaction(write_options, txn_options);
@@ -175,10 +175,10 @@ TEST_F(OptimisticTransactionTest, ReadConflictTest) {
   ASSERT_EQ(value, "bar");
 
   // This Put outside of a transaction will conflict with the previous read
-  s = db->Put(write_options, "foo", "barz");
+  s = txn_db->Put(write_options, "foo", "barz");
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "foo", &value);
+  s = txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "barz");
 
   s = txn->Commit();
@@ -219,8 +219,8 @@ TEST_F(OptimisticTransactionTest, FlushTest) {
   string value;
   Status s;
 
-  db->Put(write_options, Slice("foo"), Slice("bar"));
-  db->Put(write_options, Slice("foo2"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo2"), Slice("bar"));
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
@@ -236,18 +236,18 @@ TEST_F(OptimisticTransactionTest, FlushTest) {
   ASSERT_EQ(value, "bar2");
 
   // Put a random key so we have a memtable to flush
-  s = db->Put(write_options, "dummy", "dummy");
+  s = txn_db->Put(write_options, "dummy", "dummy");
   ASSERT_OK(s);
 
   // force a memtable flush
   FlushOptions flush_ops;
-  db->Flush(flush_ops);
+  txn_db->Flush(flush_ops);
 
   s = txn->Commit();
   // txn should commit since the flushed table is still in MemtableList History
   ASSERT_OK(s);
 
-  db->Get(read_options, "foo", &value);
+  txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "bar2");
 
   delete txn;
@@ -259,8 +259,8 @@ TEST_F(OptimisticTransactionTest, FlushTest2) {
   string value;
   Status s;
 
-  db->Put(write_options, Slice("foo"), Slice("bar"));
-  db->Put(write_options, Slice("foo2"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo"), Slice("bar"));
+  txn_db->Put(write_options, Slice("foo2"), Slice("bar"));
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
@@ -276,33 +276,33 @@ TEST_F(OptimisticTransactionTest, FlushTest2) {
   ASSERT_EQ(value, "bar2");
 
   // Put a random key so we have a MemTable to flush
-  s = db->Put(write_options, "dummy", "dummy");
+  s = txn_db->Put(write_options, "dummy", "dummy");
   ASSERT_OK(s);
 
   // force a memtable flush
   FlushOptions flush_ops;
-  db->Flush(flush_ops);
+  txn_db->Flush(flush_ops);
 
   // Put a random key so we have a MemTable to flush
-  s = db->Put(write_options, "dummy", "dummy2");
+  s = txn_db->Put(write_options, "dummy", "dummy2");
   ASSERT_OK(s);
 
   // force a memtable flush
-  db->Flush(flush_ops);
+  txn_db->Flush(flush_ops);
 
-  s = db->Put(write_options, "dummy", "dummy3");
+  s = txn_db->Put(write_options, "dummy", "dummy3");
   ASSERT_OK(s);
 
   // force a memtable flush
   // Since our test db has max_write_buffer_number=2, this flush will cause
   // the first memtable to get purged from the MemtableList history.
-  db->Flush(flush_ops);
+  txn_db->Flush(flush_ops);
 
   s = txn->Commit();
   // txn should not commit since MemTableList History is not large enough
   ASSERT_TRUE(s.IsTryAgain());
 
-  db->Get(read_options, "foo", &value);
+  txn_db->Get(read_options, "foo", &value);
   ASSERT_EQ(value, "bar");
 
   delete txn;
@@ -314,13 +314,13 @@ TEST_F(OptimisticTransactionTest, NoSnapshotTest) {
   string value;
   Status s;
 
-  db->Put(write_options, "AAA", "bar");
+  txn_db->Put(write_options, "AAA", "bar");
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
 
   // Modify key after transaction start
-  db->Put(write_options, "AAA", "bar1");
+  txn_db->Put(write_options, "AAA", "bar1");
 
   // Read and write without a snapshot
   txn->GetForUpdate(read_options, "AAA", &value);
@@ -343,14 +343,14 @@ TEST_F(OptimisticTransactionTest, MultipleSnapshotTest) {
   string value;
   Status s;
 
-  db->Put(write_options, "AAA", "bar");
-  db->Put(write_options, "BBB", "bar");
-  db->Put(write_options, "CCC", "bar");
+  txn_db->Put(write_options, "AAA", "bar");
+  txn_db->Put(write_options, "BBB", "bar");
+  txn_db->Put(write_options, "CCC", "bar");
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
 
-  db->Put(write_options, "AAA", "bar1");
+  txn_db->Put(write_options, "AAA", "bar1");
 
   // Read and write without a snapshot
   txn->GetForUpdate(read_options, "AAA", &value);
@@ -358,7 +358,7 @@ TEST_F(OptimisticTransactionTest, MultipleSnapshotTest) {
   txn->Put("AAA", "bar2");
 
   // Modify BBB before snapshot is taken
-  db->Put(write_options, "BBB", "bar1");
+  txn_db->Put(write_options, "BBB", "bar1");
 
   txn->SetSnapshot();
   snapshot_read_options.snapshot = txn->GetSnapshot();
@@ -368,7 +368,7 @@ TEST_F(OptimisticTransactionTest, MultipleSnapshotTest) {
   ASSERT_EQ(value, "bar1");
   txn->Put("BBB", "bar2");
 
-  db->Put(write_options, "CCC", "bar1");
+  txn_db->Put(write_options, "CCC", "bar1");
 
   // Set a new snapshot
   txn->SetSnapshot();
@@ -389,26 +389,26 @@ TEST_F(OptimisticTransactionTest, MultipleSnapshotTest) {
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar2");
 
-  s = db->Get(read_options, "AAA", &value);
+  s = txn_db->Get(read_options, "AAA", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar1");
-  s = db->Get(read_options, "BBB", &value);
+  s = txn_db->Get(read_options, "BBB", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar1");
-  s = db->Get(read_options, "CCC", &value);
+  s = txn_db->Get(read_options, "CCC", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar1");
 
   s = txn->Commit();
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "AAA", &value);
+  s = txn_db->Get(read_options, "AAA", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar2");
-  s = db->Get(read_options, "BBB", &value);
+  s = txn_db->Get(read_options, "BBB", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar2");
-  s = db->Get(read_options, "CCC", &value);
+  s = txn_db->Get(read_options, "CCC", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "bar2");
 
@@ -417,8 +417,8 @@ TEST_F(OptimisticTransactionTest, MultipleSnapshotTest) {
   txn = txn_db->BeginTransaction(write_options);
 
   // Potentially conflicting writes
-  db->Put(write_options, "ZZZ", "zzz");
-  db->Put(write_options, "XXX", "xxx");
+  txn_db->Put(write_options, "ZZZ", "zzz");
+  txn_db->Put(write_options, "XXX", "xxx");
 
   txn->SetSnapshot();
 
@@ -455,14 +455,15 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   ColumnFamilyOptions cf_options;
 
   // Create 2 new column families
-  s = db->CreateColumnFamily(cf_options, "CFA", &cfa);
+  s = txn_db->CreateColumnFamily(cf_options, "CFA", &cfa);
   ASSERT_OK(s);
-  s = db->CreateColumnFamily(cf_options, "CFB", &cfb);
+  s = txn_db->CreateColumnFamily(cf_options, "CFB", &cfb);
   ASSERT_OK(s);
 
   delete cfa;
   delete cfb;
   delete txn_db;
+  txn_db = nullptr;
 
   // open DB with three column families
   std::vector<ColumnFamilyDescriptor> column_families;
@@ -478,7 +479,7 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   s = OptimisticTransactionDB::Open(options, dbname, column_families, &handles,
                                     &txn_db);
   ASSERT_OK(s);
-  db = txn_db->GetBaseDB();
+  assert(txn_db != nullptr);
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn);
@@ -495,9 +496,9 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   batch.Put("foo", "foo");
   batch.Put(handles[1], "AAA", "bar");
   batch.Put(handles[1], "AAAZZZ", "bar");
-  s = db->Write(write_options, &batch);
+  s = txn_db->Write(write_options, &batch);
   ASSERT_OK(s);
-  db->Delete(write_options, handles[1], "AAAZZZ");
+  txn_db->Delete(write_options, handles[1], "AAAZZZ");
 
   // These keys do no conflict with existing writes since they're in
   // different column families
@@ -512,9 +513,9 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   // Txn should commit
   s = txn->Commit();
   ASSERT_OK(s);
-  s = db->Get(read_options, "AAA", &value);
+  s = txn_db->Get(read_options, "AAA", &value);
   ASSERT_TRUE(s.IsNotFound());
-  s = db->Get(read_options, handles[2], "AAAZZZ", &value);
+  s = txn_db->Get(read_options, handles[2], "AAAZZZ", &value);
   ASSERT_EQ(value, "barbar");
 
   Slice key_slices[3] = {Slice("AAA"), Slice("ZZ"), Slice("Z")};
@@ -530,7 +531,7 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   // Verify txn did not commit
   s = txn2->Commit();
   ASSERT_TRUE(s.IsBusy());
-  s = db->Get(read_options, handles[1], "AAAZZZ", &value);
+  s = txn_db->Get(read_options, handles[1], "AAAZZZ", &value);
   ASSERT_EQ(value, "barbar");
 
   delete txn;
@@ -568,11 +569,11 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   // Txn should commit
   s = txn->Commit();
   ASSERT_OK(s);
-  s = db->Get(read_options, handles[2], "ZZZ", &value);
+  s = txn_db->Get(read_options, handles[2], "ZZZ", &value);
   ASSERT_TRUE(s.IsNotFound());
 
   // Put a key which will conflict with the next txn using the previous snapshot
-  db->Put(write_options, handles[2], "foo", "000");
+  txn_db->Put(write_options, handles[2], "foo", "000");
 
   results = txn2->MultiGetForUpdate(snapshot_read_options, multiget_cfh,
                                     multiget_keys, &values);
@@ -588,9 +589,9 @@ TEST_F(OptimisticTransactionTest, ColumnFamiliesTest) {
   s = txn2->Commit();
   ASSERT_TRUE(s.IsBusy());
 
-  s = db->DropColumnFamily(handles[1]);
+  s = txn_db->DropColumnFamily(handles[1]);
   ASSERT_OK(s);
-  s = db->DropColumnFamily(handles[2]);
+  s = txn_db->DropColumnFamily(handles[2]);
   ASSERT_OK(s);
 
   delete txn;
@@ -607,7 +608,7 @@ TEST_F(OptimisticTransactionTest, EmptyTest) {
   string value;
   Status s;
 
-  s = db->Put(write_options, "aaa", "aaa");
+  s = txn_db->Put(write_options, "aaa", "aaa");
   ASSERT_OK(s);
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
@@ -632,7 +633,7 @@ TEST_F(OptimisticTransactionTest, EmptyTest) {
   s = txn->GetForUpdate(read_options, "aaa", &value);
   ASSERT_EQ(value, "aaa");
 
-  s = db->Put(write_options, "aaa", "xxx");
+  s = txn_db->Put(write_options, "aaa", "xxx");
   s = txn->Commit();
   ASSERT_TRUE(s.IsBusy());
   delete txn;
@@ -795,7 +796,7 @@ TEST_F(OptimisticTransactionTest, LostUpdate) {
   delete txn1;
   delete txn2;
 
-  s = db->Get(read_options, "1", &value);
+  s = txn_db->Get(read_options, "1", &value);
   ASSERT_OK(s);
   ASSERT_EQ(value, "8");
 }
@@ -810,7 +811,7 @@ TEST_F(OptimisticTransactionTest, UntrackedWrites) {
   Transaction* txn = txn_db->BeginTransaction(write_options);
   txn->PutUntracked("untracked", "0");
   txn->Rollback();
-  s = db->Get(read_options, "untracked", &value);
+  s = txn_db->Get(read_options, "untracked", &value);
   ASSERT_TRUE(s.IsNotFound());
 
   delete txn;
@@ -823,13 +824,13 @@ TEST_F(OptimisticTransactionTest, UntrackedWrites) {
 
   // Write to the untracked key outside of the transaction and verify
   // it doesn't prevent the transaction from committing.
-  s = db->Put(write_options, "untracked", "x");
+  s = txn_db->Put(write_options, "untracked", "x");
   ASSERT_OK(s);
 
   s = txn->Commit();
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "untracked", &value);
+  s = txn_db->Get(read_options, "untracked", &value);
   ASSERT_TRUE(s.IsNotFound());
 
   delete txn;
@@ -840,12 +841,12 @@ TEST_F(OptimisticTransactionTest, UntrackedWrites) {
 
   // Write to tracked key outside of the transaction and verify that the
   // untracked keys are not written when the commit fails.
-  s = db->Delete(write_options, "tracked");
+  s = txn_db->Delete(write_options, "tracked");
 
   s = txn->Commit();
   ASSERT_TRUE(s.IsBusy());
 
-  s = db->Get(read_options, "untracked", &value);
+  s = txn_db->Get(read_options, "untracked", &value);
   ASSERT_TRUE(s.IsNotFound());
 
   delete txn;
@@ -859,19 +860,19 @@ TEST_F(OptimisticTransactionTest, IteratorTest) {
   Status s;
 
   // Write some keys to the db
-  s = db->Put(write_options, "A", "a");
+  s = txn_db->Put(write_options, "A", "a");
   ASSERT_OK(s);
 
-  s = db->Put(write_options, "G", "g");
+  s = txn_db->Put(write_options, "G", "g");
   ASSERT_OK(s);
 
-  s = db->Put(write_options, "F", "f");
+  s = txn_db->Put(write_options, "F", "f");
   ASSERT_OK(s);
 
-  s = db->Put(write_options, "C", "c");
+  s = txn_db->Put(write_options, "C", "c");
   ASSERT_OK(s);
 
-  s = db->Put(write_options, "D", "d");
+  s = txn_db->Put(write_options, "D", "d");
   ASSERT_OK(s);
 
   Transaction* txn = txn_db->BeginTransaction(write_options);
@@ -894,10 +895,10 @@ TEST_F(OptimisticTransactionTest, IteratorTest) {
   const Snapshot* snapshot = txn->GetSnapshot();
 
   // Write some keys to the db after the snapshot
-  s = db->Put(write_options, "BB", "xx");
+  s = txn_db->Put(write_options, "BB", "xx");
   ASSERT_OK(s);
 
-  s = db->Put(write_options, "C", "xx");
+  s = txn_db->Put(write_options, "C", "xx");
   ASSERT_OK(s);
 
   read_options.snapshot = snapshot;
@@ -991,7 +992,7 @@ TEST_F(OptimisticTransactionTest, SavepointTest) {
   s = txn->Commit();
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "B", &value);
+  s = txn_db->Get(read_options, "B", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b", value);
 
@@ -1103,28 +1104,28 @@ TEST_F(OptimisticTransactionTest, SavepointTest) {
   s = txn->Commit();
   ASSERT_OK(s);
 
-  s = db->Get(read_options, "F", &value);
+  s = txn_db->Get(read_options, "F", &value);
   ASSERT_OK(s);
   ASSERT_EQ("f", value);
 
-  s = db->Get(read_options, "G", &value);
+  s = txn_db->Get(read_options, "G", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = db->Get(read_options, "A", &value);
+  s = txn_db->Get(read_options, "A", &value);
   ASSERT_OK(s);
   ASSERT_EQ("aa", value);
 
-  s = db->Get(read_options, "B", &value);
+  s = txn_db->Get(read_options, "B", &value);
   ASSERT_OK(s);
   ASSERT_EQ("b", value);
 
-  s = db->Get(read_options, "C", &value);
+  s = txn_db->Get(read_options, "C", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = db->Get(read_options, "D", &value);
+  s = txn_db->Get(read_options, "D", &value);
   ASSERT_TRUE(s.IsNotFound());
 
-  s = db->Get(read_options, "E", &value);
+  s = txn_db->Get(read_options, "E", &value);
   ASSERT_TRUE(s.IsNotFound());
 
   delete txn;
@@ -1137,7 +1138,7 @@ TEST_F(OptimisticTransactionTest, UndoGetForUpdateTest) {
   string value;
   Status s;
 
-  db->Put(write_options, "A", "");
+  txn_db->Put(write_options, "A", "");
 
   Transaction* txn1 = txn_db->BeginTransaction(write_options);
   ASSERT_TRUE(txn1);
@@ -1346,7 +1347,7 @@ TEST_F(OptimisticTransactionTest, OptimisticTransactionStressTest) {
   }
 
   // Verify that data is consistent
-  Status s = RandomTransactionInserter::Verify(db, num_sets);
+  Status s = RandomTransactionInserter::Verify(txn_db, num_sets);
   ASSERT_OK(s);
 }
 
@@ -1387,7 +1388,7 @@ int main(int argc, char** argv) {
 #else
 #include <stdio.h>
 
-int main(int argc, char** argv) {
+int main(int /*argc*/, char** /*argv*/) {
   fprintf(
       stderr,
       "SKIPPED as optimistic_transaction is not supported in ROCKSDB_LITE\n");