@nxtedition/rocksdb 7.1.29 → 7.1.31

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_format_test.cc

@@ -5,12 +5,12 @@
 
 #include <cstring>
 #include <memory>
+
 #include "test_util/testharness.h"
 #include "utilities/cassandra/format.h"
 #include "utilities/cassandra/serialize.h"
 #include "utilities/cassandra/test_utils.h"
 
-
 namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 
@@ -51,8 +51,8 @@ TEST(ColumnTest, Column) {
 
   c1->Serialize(&dest);
   EXPECT_EQ(dest.size(), 2 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) ==
+              0);
 
   // Verify the ColumnBase::Deserialization.
   saved_dest = dest;
@@ -60,9 +60,8 @@ TEST(ColumnTest, Column) {
       ColumnBase::Deserialize(saved_dest.c_str(), c.Size());
   c2->Serialize(&dest);
   EXPECT_EQ(dest.size(), 3 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2, c.Size())
-      == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2,
+                          c.Size()) == 0);
 }
 
 TEST(ExpiringColumnTest, ExpiringColumn) {
@@ -71,8 +70,8 @@ TEST(ExpiringColumnTest, ExpiringColumn) {
   int8_t index = 3;
   int64_t timestamp = 1494022807044;
   int32_t ttl = 3600;
-  ExpiringColumn c = ExpiringColumn(mask, index, timestamp,
-                                    sizeof(data), data, ttl);
+  ExpiringColumn c =
+      ExpiringColumn(mask, index, timestamp, sizeof(data), data, ttl);
 
   EXPECT_EQ(c.Index(), index);
   EXPECT_EQ(c.Timestamp(), timestamp);
@@ -107,8 +106,8 @@ TEST(ExpiringColumnTest, ExpiringColumn) {
 
   c1->Serialize(&dest);
   EXPECT_EQ(dest.size(), 2 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) ==
+              0);
 
   // Verify the ColumnBase::Deserialization.
   saved_dest = dest;
@@ -116,23 +115,24 @@ TEST(ExpiringColumnTest, ExpiringColumn) {
       ColumnBase::Deserialize(saved_dest.c_str(), c.Size());
   c2->Serialize(&dest);
   EXPECT_EQ(dest.size(), 3 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2, c.Size())
-      == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2,
+                          c.Size()) == 0);
 }
 
 TEST(TombstoneTest, TombstoneCollectable) {
   int32_t now = (int32_t)time(nullptr);
   int32_t gc_grace_seconds = 16440;
   int32_t time_delta_seconds = 10;
-  EXPECT_TRUE(Tombstone(ColumnTypeMask::DELETION_MASK, 0,
-                        now - gc_grace_seconds - time_delta_seconds,
-                        ToMicroSeconds(now - gc_grace_seconds - time_delta_seconds))
-                  .Collectable(gc_grace_seconds));
-  EXPECT_FALSE(Tombstone(ColumnTypeMask::DELETION_MASK, 0,
-                         now - gc_grace_seconds + time_delta_seconds,
-                         ToMicroSeconds(now - gc_grace_seconds + time_delta_seconds))
-                   .Collectable(gc_grace_seconds));
+  EXPECT_TRUE(
+      Tombstone(ColumnTypeMask::DELETION_MASK, 0,
+                now - gc_grace_seconds - time_delta_seconds,
+                ToMicroSeconds(now - gc_grace_seconds - time_delta_seconds))
+          .Collectable(gc_grace_seconds));
+  EXPECT_FALSE(
+      Tombstone(ColumnTypeMask::DELETION_MASK, 0,
+                now - gc_grace_seconds + time_delta_seconds,
+                ToMicroSeconds(now - gc_grace_seconds + time_delta_seconds))
+          .Collectable(gc_grace_seconds));
 }
 
 TEST(TombstoneTest, Tombstone) {
@@ -140,8 +140,8 @@ TEST(TombstoneTest, Tombstone) {
   int8_t index = 2;
   int32_t local_deletion_time = 1494022807;
   int64_t marked_for_delete_at = 1494022807044;
-  Tombstone c = Tombstone(mask, index, local_deletion_time,
-                          marked_for_delete_at);
+  Tombstone c =
+      Tombstone(mask, index, local_deletion_time, marked_for_delete_at);
 
   EXPECT_EQ(c.Index(), index);
   EXPECT_EQ(c.Timestamp(), marked_for_delete_at);
@@ -170,17 +170,16 @@ TEST(TombstoneTest, Tombstone) {
 
   c1->Serialize(&dest);
   EXPECT_EQ(dest.size(), 2 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str(), dest.c_str() + c.Size(), c.Size()) ==
+              0);
 
   // Verify the ColumnBase::Deserialization.
   std::shared_ptr<ColumnBase> c2 =
-    ColumnBase::Deserialize(dest.c_str(), c.Size());
+      ColumnBase::Deserialize(dest.c_str(), c.Size());
   c2->Serialize(&dest);
   EXPECT_EQ(dest.size(), 3 * c.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2, c.Size())
-      == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str() + c.Size(), dest.c_str() + c.Size() * 2,
+                          c.Size()) == 0);
 }
 
 class RowValueTest : public testing::Test {};
@@ -213,8 +212,8 @@ TEST(RowValueTest, RowTombstone) {
 
   r1.Serialize(&dest);
   EXPECT_EQ(dest.size(), 2 * r.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str(), dest.c_str() + r.Size(), r.Size()) == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str(), dest.c_str() + r.Size(), r.Size()) ==
+              0);
 }
 
 TEST(RowValueTest, RowWithColumns) {
@@ -227,23 +226,23 @@ TEST(RowValueTest, RowWithColumns) {
   int64_t e_timestamp = 1494022807044;
   int32_t e_ttl = 3600;
   columns.push_back(std::shared_ptr<ExpiringColumn>(
-    new ExpiringColumn(ColumnTypeMask::EXPIRATION_MASK, e_index,
-      e_timestamp, sizeof(e_data), e_data, e_ttl)));
+      new ExpiringColumn(ColumnTypeMask::EXPIRATION_MASK, e_index, e_timestamp,
+                         sizeof(e_data), e_data, e_ttl)));
   columns_data_size += columns[0]->Size();
 
   char c_data[4] = {'d', 'a', 't', 'a'};
   int8_t c_index = 1;
   int64_t c_timestamp = 1494022807048;
   columns.push_back(std::shared_ptr<Column>(
-    new Column(0, c_index, c_timestamp, sizeof(c_data), c_data)));
+      new Column(0, c_index, c_timestamp, sizeof(c_data), c_data)));
   columns_data_size += columns[1]->Size();
 
   int8_t t_index = 2;
   int32_t t_local_deletion_time = 1494022801;
   int64_t t_marked_for_delete_at = 1494022807043;
   columns.push_back(std::shared_ptr<Tombstone>(
-    new Tombstone(ColumnTypeMask::DELETION_MASK,
-      t_index, t_local_deletion_time, t_marked_for_delete_at)));
+      new Tombstone(ColumnTypeMask::DELETION_MASK, t_index,
+                    t_local_deletion_time, t_marked_for_delete_at)));
   columns_data_size += columns[2]->Size();
 
   RowValue r = RowValue(std::move(columns), last_modified_time);
@@ -260,15 +259,15 @@ TEST(RowValueTest, RowWithColumns) {
   EXPECT_EQ(dest.size(), r.Size());
   std::size_t offset = 0;
   EXPECT_EQ(Deserialize<int32_t>(dest.c_str(), offset),
-    std::numeric_limits<int32_t>::max());
+            std::numeric_limits<int32_t>::max());
   offset += sizeof(int32_t);
   EXPECT_EQ(Deserialize<int64_t>(dest.c_str(), offset),
-    std::numeric_limits<int64_t>::min());
+            std::numeric_limits<int64_t>::min());
   offset += sizeof(int64_t);
 
   // Column0: ExpiringColumn
   EXPECT_EQ(Deserialize<int8_t>(dest.c_str(), offset),
-    ColumnTypeMask::EXPIRATION_MASK);
+            ColumnTypeMask::EXPIRATION_MASK);
   offset += sizeof(int8_t);
   EXPECT_EQ(Deserialize<int8_t>(dest.c_str(), offset), e_index);
   offset += sizeof(int8_t);
@@ -295,7 +294,7 @@ TEST(RowValueTest, RowWithColumns) {
 
   // Column2: Tombstone
   EXPECT_EQ(Deserialize<int8_t>(dest.c_str(), offset),
-    ColumnTypeMask::DELETION_MASK);
+            ColumnTypeMask::DELETION_MASK);
   offset += sizeof(int8_t);
   EXPECT_EQ(Deserialize<int8_t>(dest.c_str(), offset), t_index);
   offset += sizeof(int8_t);
@@ -311,19 +310,20 @@ TEST(RowValueTest, RowWithColumns) {
 
   r1.Serialize(&dest);
   EXPECT_EQ(dest.size(), 2 * r.Size());
-  EXPECT_TRUE(
-    std::memcmp(dest.c_str(), dest.c_str() + r.Size(), r.Size()) == 0);
+  EXPECT_TRUE(std::memcmp(dest.c_str(), dest.c_str() + r.Size(), r.Size()) ==
+              0);
 }
 
 TEST(RowValueTest, PurgeTtlShouldRemvoeAllColumnsExpired) {
   int64_t now = time(nullptr);
 
-  auto row_value = CreateTestRowValue({
-    CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now)),
-    CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now - kTtl - 10)), //expired
-    CreateTestColumnSpec(kExpiringColumn, 2, ToMicroSeconds(now)), // not expired
-    CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))
-  });
+  auto row_value = CreateTestRowValue(
+      {CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now)),
+       CreateTestColumnSpec(kExpiringColumn, 1,
+                            ToMicroSeconds(now - kTtl - 10)),  // expired
+       CreateTestColumnSpec(kExpiringColumn, 2,
+                            ToMicroSeconds(now)),  // not expired
+       CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))});
 
   bool changed = false;
   auto purged = row_value.RemoveExpiredColumns(&changed);
@@ -343,12 +343,13 @@ TEST(RowValueTest, PurgeTtlShouldRemvoeAllColumnsExpired) {
 TEST(RowValueTest, ExpireTtlShouldConvertExpiredColumnsToTombstones) {
   int64_t now = time(nullptr);
 
-  auto row_value = CreateTestRowValue({
-    CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now)),
-    CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now - kTtl - 10)), //expired
-    CreateTestColumnSpec(kExpiringColumn, 2, ToMicroSeconds(now)), // not expired
-    CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))
-  });
+  auto row_value = CreateTestRowValue(
+      {CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now)),
+       CreateTestColumnSpec(kExpiringColumn, 1,
+                            ToMicroSeconds(now - kTtl - 10)),  // expired
+       CreateTestColumnSpec(kExpiringColumn, 2,
+                            ToMicroSeconds(now)),  // not expired
+       CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))});
 
   bool changed = false;
   auto compacted = row_value.ConvertExpiredColumnsToTombstones(&changed);
@@ -366,7 +367,7 @@ TEST(RowValueTest, ExpireTtlShouldConvertExpiredColumnsToTombstones) {
   compacted.ConvertExpiredColumnsToTombstones(&changed);
   EXPECT_FALSE(changed);
 }
-} // namespace cassandra
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_functional_test.cc

@@ -18,7 +18,6 @@
 #include "utilities/cassandra/test_utils.h"
 #include "utilities/merge_operators.h"
 
-
 namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 
@@ -32,7 +31,7 @@ class CassandraStore {
     assert(db);
   }
 
-  bool Append(const std::string& key, const RowValue& val){
+  bool Append(const std::string& key, const RowValue& val) {
     std::string result;
     val.Serialize(&result);
     Slice valSlice(result.data(), result.size());
@@ -72,14 +71,13 @@ class CassandraStore {
                                        db_->DefaultColumnFamily());
   }
 
-  std::tuple<bool, RowValue> Get(const std::string& key){
+  std::tuple<bool, RowValue> Get(const std::string& key) {
     std::string result;
     auto s = db_->Get(get_option_, key, &result);
 
     if (s.ok()) {
-      return std::make_tuple(true,
-                             RowValue::Deserialize(result.data(),
-                                                   result.size()));
+      return std::make_tuple(
+          true, RowValue::Deserialize(result.data(), result.size()));
     }
 
     if (!s.IsNotFound()) {
@@ -98,29 +96,28 @@ class CassandraStore {
 };
 
 class TestCompactionFilterFactory : public CompactionFilterFactory {
-public:
- explicit TestCompactionFilterFactory(bool purge_ttl_on_expiration,
-                                      int32_t gc_grace_period_in_seconds)
-     : purge_ttl_on_expiration_(purge_ttl_on_expiration),
-       gc_grace_period_in_seconds_(gc_grace_period_in_seconds) {}
-
- std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-     const CompactionFilter::Context& /*context*/) override {
-   return std::unique_ptr<CompactionFilter>(new CassandraCompactionFilter(
-       purge_ttl_on_expiration_, gc_grace_period_in_seconds_));
- }
+ public:
+  explicit TestCompactionFilterFactory(bool purge_ttl_on_expiration,
+                                       int32_t gc_grace_period_in_seconds)
+      : purge_ttl_on_expiration_(purge_ttl_on_expiration),
+        gc_grace_period_in_seconds_(gc_grace_period_in_seconds) {}
+
+  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+      const CompactionFilter::Context& /*context*/) override {
+    return std::unique_ptr<CompactionFilter>(new CassandraCompactionFilter(
+        purge_ttl_on_expiration_, gc_grace_period_in_seconds_));
+  }
 
- const char* Name() const override { return "TestCompactionFilterFactory"; }
+  const char* Name() const override { return "TestCompactionFilterFactory"; }
 
-private:
+ private:
   bool purge_ttl_on_expiration_;
   int32_t gc_grace_period_in_seconds_;
 };
 
-
 // The class for unit-testing
 class CassandraFunctionalTest : public testing::Test {
-public:
+ public:
   CassandraFunctionalTest() {
     EXPECT_OK(
         DestroyDB(kDbName, Options()));  // Start each test with a fresh DB
@@ -130,7 +127,8 @@ public:
     DB* db;
     Options options;
     options.create_if_missing = true;
-    options.merge_operator.reset(new CassandraValueMergeOperator(gc_grace_period_in_seconds_));
+    options.merge_operator.reset(
+        new CassandraValueMergeOperator(gc_grace_period_in_seconds_));
     auto* cf_factory = new TestCompactionFilterFactory(
         purge_ttl_on_expiration_, gc_grace_period_in_seconds_);
     options.compaction_filter_factory.reset(cf_factory);
@@ -148,23 +146,29 @@ TEST_F(CassandraFunctionalTest, SimpleMergeTest) {
   CassandraStore store(OpenDb());
   int64_t now = time(nullptr);
 
-  store.Append("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kTombstone, 0, ToMicroSeconds(now + 5)),
-    CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now + 8)),
-    CreateTestColumnSpec(kExpiringColumn, 2, ToMicroSeconds(now + 5)),
-  }));
-  store.Append("k1",CreateTestRowValue({
-    CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now + 2)),
-    CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now + 5)),
-    CreateTestColumnSpec(kTombstone, 2, ToMicroSeconds(now + 7)),
-    CreateTestColumnSpec(kExpiringColumn, 7, ToMicroSeconds(now + 17)),
-  }));
-  store.Append("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now + 6)),
-    CreateTestColumnSpec(kTombstone, 1, ToMicroSeconds(now + 5)),
-    CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now + 4)),
-    CreateTestColumnSpec(kTombstone, 11, ToMicroSeconds(now + 11)),
-  }));
+  store.Append(
+      "k1",
+      CreateTestRowValue({
+          CreateTestColumnSpec(kTombstone, 0, ToMicroSeconds(now + 5)),
+          CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now + 8)),
+          CreateTestColumnSpec(kExpiringColumn, 2, ToMicroSeconds(now + 5)),
+      }));
+  store.Append(
+      "k1",
+      CreateTestRowValue({
+          CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now + 2)),
+          CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now + 5)),
+          CreateTestColumnSpec(kTombstone, 2, ToMicroSeconds(now + 7)),
+          CreateTestColumnSpec(kExpiringColumn, 7, ToMicroSeconds(now + 17)),
+      }));
+  store.Append(
+      "k1",
+      CreateTestRowValue({
+          CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now + 6)),
+          CreateTestColumnSpec(kTombstone, 1, ToMicroSeconds(now + 5)),
+          CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now + 4)),
+          CreateTestColumnSpec(kTombstone, 11, ToMicroSeconds(now + 11)),
+      }));
 
   auto ret = store.Get("k1");
 
@@ -188,7 +192,7 @@ constexpr int64_t kTestTimeoutSecs = 600;
 TEST_F(CassandraFunctionalTest,
        CompactionShouldConvertExpiredColumnsToTombstone) {
   CassandraStore store(OpenDb());
-  int64_t now= time(nullptr);
+  int64_t now = time(nullptr);
 
   store.Append(
       "k1",
@@ -202,10 +206,12 @@ TEST_F(CassandraFunctionalTest,
 
   ASSERT_OK(store.Flush());
 
-  store.Append("k1",CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now - kTtl - 10)), //expired
-    CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now))
-  }));
+  store.Append(
+      "k1",
+      CreateTestRowValue(
+          {CreateTestColumnSpec(kExpiringColumn, 0,
+                                ToMicroSeconds(now - kTtl - 10)),  // expired
+           CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now))}));
 
   ASSERT_OK(store.Flush());
   ASSERT_OK(store.Compact());
@@ -224,25 +230,29 @@ TEST_F(CassandraFunctionalTest,
                         ToMicroSeconds(now));
 }
 
-
 TEST_F(CassandraFunctionalTest,
        CompactionShouldPurgeExpiredColumnsIfPurgeTtlIsOn) {
   purge_ttl_on_expiration_ = true;
   CassandraStore store(OpenDb());
   int64_t now = time(nullptr);
 
-  store.Append("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now - kTtl - 20)), //expired
-    CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now)), // not expired
-    CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))
-  }));
+  store.Append(
+      "k1",
+      CreateTestRowValue(
+          {CreateTestColumnSpec(kExpiringColumn, 0,
+                                ToMicroSeconds(now - kTtl - 20)),  // expired
+           CreateTestColumnSpec(kExpiringColumn, 1,
+                                ToMicroSeconds(now)),  // not expired
+           CreateTestColumnSpec(kTombstone, 3, ToMicroSeconds(now))}));
 
   ASSERT_OK(store.Flush());
 
-  store.Append("k1",CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now - kTtl - 10)), //expired
-    CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now))
-  }));
+  store.Append(
+      "k1",
+      CreateTestRowValue(
+          {CreateTestColumnSpec(kExpiringColumn, 0,
+                                ToMicroSeconds(now - kTtl - 10)),  // expired
+           CreateTestColumnSpec(kColumn, 2, ToMicroSeconds(now))}));
 
   ASSERT_OK(store.Flush());
   ASSERT_OK(store.Compact());
@@ -266,15 +276,18 @@ TEST_F(CassandraFunctionalTest,
   int64_t now = time(nullptr);
 
   store.Append("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now - kTtl - 20)),
-    CreateTestColumnSpec(kExpiringColumn, 1, ToMicroSeconds(now - kTtl - 20)),
-  }));
+                         CreateTestColumnSpec(kExpiringColumn, 0,
+                                              ToMicroSeconds(now - kTtl - 20)),
+                         CreateTestColumnSpec(kExpiringColumn, 1,
+                                              ToMicroSeconds(now - kTtl - 20)),
+                     }));
 
   ASSERT_OK(store.Flush());
 
-  store.Append("k1",CreateTestRowValue({
-    CreateTestColumnSpec(kExpiringColumn, 0, ToMicroSeconds(now - kTtl - 10)),
-  }));
+  store.Append("k1", CreateTestRowValue({
+                         CreateTestColumnSpec(kExpiringColumn, 0,
+                                              ToMicroSeconds(now - kTtl - 10)),
+                     }));
 
   ASSERT_OK(store.Flush());
   ASSERT_OK(store.Compact());
@@ -287,20 +300,21 @@ TEST_F(CassandraFunctionalTest,
   CassandraStore store(OpenDb());
   int64_t now = time(nullptr);
 
-  store.Append("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kTombstone, 0, ToMicroSeconds(now - gc_grace_period_in_seconds_ - 1)),
-    CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now))
-  }));
+  store.Append("k1",
+               CreateTestRowValue(
+                   {CreateTestColumnSpec(
+                        kTombstone, 0,
+                        ToMicroSeconds(now - gc_grace_period_in_seconds_ - 1)),
+                    CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now))}));
 
-  store.Append("k2", CreateTestRowValue({
-    CreateTestColumnSpec(kColumn, 0, ToMicroSeconds(now))
-  }));
+  store.Append("k2", CreateTestRowValue({CreateTestColumnSpec(
+                         kColumn, 0, ToMicroSeconds(now))}));
 
   ASSERT_OK(store.Flush());
 
-  store.Append("k1",CreateTestRowValue({
-    CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now)),
-  }));
+  store.Append("k1", CreateTestRowValue({
+                         CreateTestColumnSpec(kColumn, 1, ToMicroSeconds(now)),
+                     }));
 
   ASSERT_OK(store.Flush());
   ASSERT_OK(store.Compact());
@@ -317,9 +331,12 @@ TEST_F(CassandraFunctionalTest, CompactionShouldRemoveTombstoneFromPut) {
   CassandraStore store(OpenDb());
   int64_t now = time(nullptr);
 
-  store.Put("k1", CreateTestRowValue({
-    CreateTestColumnSpec(kTombstone, 0, ToMicroSeconds(now - gc_grace_period_in_seconds_ - 1)),
-  }));
+  store.Put("k1",
+            CreateTestRowValue({
+                CreateTestColumnSpec(
+                    kTombstone, 0,
+                    ToMicroSeconds(now - gc_grace_period_in_seconds_ - 1)),
+            }));
 
   ASSERT_OK(store.Flush());
   ASSERT_OK(store.Compact());
@@ -419,7 +436,7 @@ TEST_F(CassandraFunctionalTest, LoadCompactionFilterFactory) {
 }
 #endif  // ROCKSDB_LITE
 
-} // namespace cassandra
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_row_merge_test.cc

@@ -4,6 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #include <memory>
+
 #include "test_util/testharness.h"
 #include "utilities/cassandra/format.h"
 #include "utilities/cassandra/test_utils.h"
@@ -15,31 +16,25 @@ class RowValueMergeTest : public testing::Test {};
 
 TEST(RowValueMergeTest, Merge) {
   std::vector<RowValue> row_values;
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kTombstone, 0, 5),
       CreateTestColumnSpec(kColumn, 1, 8),
       CreateTestColumnSpec(kExpiringColumn, 2, 5),
-    })
-  );
+  }));
 
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kColumn, 0, 2),
       CreateTestColumnSpec(kExpiringColumn, 1, 5),
       CreateTestColumnSpec(kTombstone, 2, 7),
       CreateTestColumnSpec(kExpiringColumn, 7, 17),
-    })
-  );
+  }));
 
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kExpiringColumn, 0, 6),
       CreateTestColumnSpec(kTombstone, 1, 5),
       CreateTestColumnSpec(kColumn, 2, 4),
       CreateTestColumnSpec(kTombstone, 11, 11),
-    })
-  );
+  }));
 
   RowValue merged = RowValue::Merge(std::move(row_values));
   EXPECT_FALSE(merged.IsTombstone());
@@ -55,33 +50,25 @@ TEST(RowValueMergeTest, MergeWithRowTombstone) {
   std::vector<RowValue> row_values;
 
   // A row tombstone.
-  row_values.push_back(
-    CreateRowTombstone(11)
-  );
+  row_values.push_back(CreateRowTombstone(11));
 
   // This row's timestamp is smaller than tombstone.
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kColumn, 0, 5),
       CreateTestColumnSpec(kColumn, 1, 6),
-    })
-  );
+  }));
 
   // Some of the column's row is smaller, some is larger.
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kColumn, 2, 10),
       CreateTestColumnSpec(kColumn, 3, 12),
-    })
-  );
+  }));
 
   // All of the column's rows are larger than tombstone.
-  row_values.push_back(
-    CreateTestRowValue({
+  row_values.push_back(CreateTestRowValue({
       CreateTestColumnSpec(kColumn, 4, 13),
       CreateTestColumnSpec(kColumn, 5, 14),
-    })
-  );
+  }));
 
   RowValue merged = RowValue::Merge(std::move(row_values));
   EXPECT_FALSE(merged.IsTombstone());
@@ -92,20 +79,16 @@ TEST(RowValueMergeTest, MergeWithRowTombstone) {
 
   // If the tombstone's timestamp is the latest, then it returns a
   // row tombstone.
-  row_values.push_back(
-    CreateRowTombstone(15)
-  );
+  row_values.push_back(CreateRowTombstone(15));
 
-  row_values.push_back(
-    CreateRowTombstone(17)
-  );
+  row_values.push_back(CreateRowTombstone(17));
 
   merged = RowValue::Merge(std::move(row_values));
   EXPECT_TRUE(merged.IsTombstone());
   EXPECT_EQ(merged.LastModifiedTime(), 17);
 }
 
-} // namespace cassandra
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {