update source to Ceph Pacific 16.2.2

[ceph.git] / ceph / src / rocksdb / java / rocksjni / write_batch_test.cc

diff --git a/ceph/src/rocksdb/java/rocksjni/write_batch_test.cc b/ceph/src/rocksdb/java/rocksjni/write_batch_test.cc
index 266fb4abf7488638f12e2722540d9762a19db782..114eac42cda5d820927ad109f60291a099009870 100644 (file)
--- a/ceph/src/rocksdb/java/rocksjni/write_batch_test.cc
+++ b/ceph/src/rocksdb/java/rocksjni/write_batch_test.cc
@@ -4,7 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //
 // This file implements the "bridge" between Java and C++ and enables
-// calling c++ rocksdb::WriteBatch methods testing from Java side.
+// calling c++ ROCKSDB_NAMESPACE::WriteBatch methods testing from Java side.
 #include <memory>
 
 #include "db/memtable.h"
@@ -22,8 +22,8 @@
 #include "rocksdb/write_buffer_manager.h"
 #include "rocksjni/portal.h"
 #include "table/scoped_arena_iterator.h"
+#include "test_util/testharness.h"
 #include "util/string_util.h"
-#include "util/testharness.h"
 
 /*
  * Class:     org_rocksdb_WriteBatchTest
@@ -33,40 +33,42 @@
 jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
                                                        jclass /*jclazz*/,
                                                        jlong jwb_handle) {
-  auto* b = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
+  auto* b = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
   assert(b != nullptr);
 
   // todo: Currently the following code is directly copied from
   // db/write_bench_test.cc.  It could be implemented in java once
   // all the necessary components can be accessed via jni api.
 
-  rocksdb::InternalKeyComparator cmp(rocksdb::BytewiseComparator());
-  auto factory = std::make_shared<rocksdb::SkipListFactory>();
-  rocksdb::Options options;
-  rocksdb::WriteBufferManager wb(options.db_write_buffer_size);
+  ROCKSDB_NAMESPACE::InternalKeyComparator cmp(
+      ROCKSDB_NAMESPACE::BytewiseComparator());
+  auto factory = std::make_shared<ROCKSDB_NAMESPACE::SkipListFactory>();
+  ROCKSDB_NAMESPACE::Options options;
+  ROCKSDB_NAMESPACE::WriteBufferManager wb(options.db_write_buffer_size);
   options.memtable_factory = factory;
-  rocksdb::MemTable* mem = new rocksdb::MemTable(
-      cmp, rocksdb::ImmutableCFOptions(options),
-      rocksdb::MutableCFOptions(options), &wb, rocksdb::kMaxSequenceNumber,
-      0 /* column_family_id */);
+  ROCKSDB_NAMESPACE::MemTable* mem = new ROCKSDB_NAMESPACE::MemTable(
+      cmp, ROCKSDB_NAMESPACE::ImmutableCFOptions(options),
+      ROCKSDB_NAMESPACE::MutableCFOptions(options), &wb,
+      ROCKSDB_NAMESPACE::kMaxSequenceNumber, 0 /* column_family_id */);
   mem->Ref();
   std::string state;
-  rocksdb::ColumnFamilyMemTablesDefault cf_mems_default(mem);
-  rocksdb::Status s =
-      rocksdb::WriteBatchInternal::InsertInto(b, &cf_mems_default, nullptr);
-  int count = 0;
-  rocksdb::Arena arena;
-  rocksdb::ScopedArenaIterator iter(
-      mem->NewIterator(rocksdb::ReadOptions(), &arena));
+  ROCKSDB_NAMESPACE::ColumnFamilyMemTablesDefault cf_mems_default(mem);
+  ROCKSDB_NAMESPACE::Status s =
+      ROCKSDB_NAMESPACE::WriteBatchInternal::InsertInto(b, &cf_mems_default,
+                                                        nullptr, nullptr);
+  unsigned int count = 0;
+  ROCKSDB_NAMESPACE::Arena arena;
+  ROCKSDB_NAMESPACE::ScopedArenaIterator iter(
+      mem->NewIterator(ROCKSDB_NAMESPACE::ReadOptions(), &arena));
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    rocksdb::ParsedInternalKey ikey;
+    ROCKSDB_NAMESPACE::ParsedInternalKey ikey;
     ikey.clear();
-    bool parsed = rocksdb::ParseInternalKey(iter->key(), &ikey);
+    bool parsed = ROCKSDB_NAMESPACE::ParseInternalKey(iter->key(), &ikey);
     if (!parsed) {
       assert(parsed);
     }
     switch (ikey.type) {
-      case rocksdb::kTypeValue:
+      case ROCKSDB_NAMESPACE::kTypeValue:
         state.append("Put(");
         state.append(ikey.user_key.ToString());
         state.append(", ");
@@ -74,7 +76,7 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
         state.append(")");
         count++;
         break;
-      case rocksdb::kTypeMerge:
+      case ROCKSDB_NAMESPACE::kTypeMerge:
         state.append("Merge(");
         state.append(ikey.user_key.ToString());
         state.append(", ");
@@ -82,19 +84,19 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
         state.append(")");
         count++;
         break;
-      case rocksdb::kTypeDeletion:
+      case ROCKSDB_NAMESPACE::kTypeDeletion:
         state.append("Delete(");
         state.append(ikey.user_key.ToString());
         state.append(")");
         count++;
         break;
-      case rocksdb::kTypeSingleDeletion:
+      case ROCKSDB_NAMESPACE::kTypeSingleDeletion:
         state.append("SingleDelete(");
         state.append(ikey.user_key.ToString());
         state.append(")");
         count++;
         break;
-      case rocksdb::kTypeRangeDeletion:
+      case ROCKSDB_NAMESPACE::kTypeRangeDeletion:
         state.append("DeleteRange(");
         state.append(ikey.user_key.ToString());
         state.append(", ");
@@ -102,7 +104,7 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
         state.append(")");
         count++;
         break;
-      case rocksdb::kTypeLogData:
+      case ROCKSDB_NAMESPACE::kTypeLogData:
         state.append("LogData(");
         state.append(ikey.user_key.ToString());
         state.append(")");
@@ -117,13 +119,14 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
         break;
     }
     state.append("@");
-    state.append(rocksdb::NumberToString(ikey.sequence));
+    state.append(ROCKSDB_NAMESPACE::NumberToString(ikey.sequence));
   }
   if (!s.ok()) {
     state.append(s.ToString());
-  } else if (rocksdb::WriteBatchInternal::Count(b) != count) {
+  } else if (ROCKSDB_NAMESPACE::WriteBatchInternal::Count(b) != count) {
     state.append("Err:CountMismatch(expected=");
-    state.append(std::to_string(rocksdb::WriteBatchInternal::Count(b)));
+    state.append(
+        std::to_string(ROCKSDB_NAMESPACE::WriteBatchInternal::Count(b)));
     state.append(", actual=");
     state.append(std::to_string(count));
     state.append(")");
@@ -155,11 +158,11 @@ jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
  */
 void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence(
     JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle, jlong jsn) {
-  auto* wb = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
+  auto* wb = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
   assert(wb != nullptr);
 
-  rocksdb::WriteBatchInternal::SetSequence(
-      wb, static_cast<rocksdb::SequenceNumber>(jsn));
+  ROCKSDB_NAMESPACE::WriteBatchInternal::SetSequence(
+      wb, static_cast<ROCKSDB_NAMESPACE::SequenceNumber>(jsn));
 }
 
 /*
@@ -170,10 +173,11 @@ void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence(
 jlong Java_org_rocksdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/,
                                                              jclass /*jclazz*/,
                                                              jlong jwb_handle) {
-  auto* wb = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
+  auto* wb = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
   assert(wb != nullptr);
 
-  return static_cast<jlong>(rocksdb::WriteBatchInternal::Sequence(wb));
+  return static_cast<jlong>(
+      ROCKSDB_NAMESPACE::WriteBatchInternal::Sequence(wb));
 }
 
 /*
@@ -185,10 +189,10 @@ void Java_org_rocksdb_WriteBatchTestInternalHelper_append(JNIEnv* /*env*/,
                                                           jclass /*jclazz*/,
                                                           jlong jwb_handle_1,
                                                           jlong jwb_handle_2) {
-  auto* wb1 = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle_1);
+  auto* wb1 = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle_1);
   assert(wb1 != nullptr);
-  auto* wb2 = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle_2);
+  auto* wb2 = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle_2);
   assert(wb2 != nullptr);
 
-  rocksdb::WriteBatchInternal::Append(wb1, wb2);
+  ROCKSDB_NAMESPACE::WriteBatchInternal::Append(wb1, wb2);
 }