Add LwwRegister CRDT

blimp/helium/lww_register_unittest.cc

Index: blimp/helium/lww_register_unittest.cc
diff --git a/blimp/helium/lww_register_unittest.cc b/blimp/helium/lww_register_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..671ab2258bb011c4a5c539991b043589ef404c52
--- /dev/null
+++ b/blimp/helium/lww_register_unittest.cc
@@ -0,0 +1,147 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "blimp/helium/lww_register.h"
+
+#include <string>
+
+#include "blimp/helium/version_vector.h"
+#include "blimp/helium/version_vector_generator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
+
+namespace blimp {
+namespace helium {
+namespace {
+
+class LwwRegisterTest : public testing::Test {
+ protected:
+  void Initialize(Peer bias) {
+    bias_ = bias;
+    client_ =
+        base::MakeUnique<LwwRegister<int>>(&client_gen_, bias_, Peer::Client);
+    engine_ =
+        base::MakeUnique<LwwRegister<int>>(&engine_gen_, bias_, Peer::Engine);
+  }
+
+  void SyncFromClient() {
+    Sync(client_.get(), engine_.get(), engine_gen_.current(),
+         client_gen_.current());
+  }
+
+  void SyncFromEngine() {
+    Sync(engine_.get(), client_.get(), client_gen_.current(),
+         engine_gen_.current());
+  }
+
+  void Sync(LwwRegister<int>* from_lww_register,
+            LwwRegister<int>* to_lww_register,
+            VersionVector from,
+            VersionVector to);
+
+  VersionVectorGenerator client_gen_;
+  VersionVectorGenerator engine_gen_;
+
+  Peer bias_;

[Kevin M, 2016/10/19 17:49:11]

Remove this field?

[steimel, 2016/10/20 00:30:07]

Done.

+
+  std::unique_ptr<LwwRegister<int>> client_;
+  std::unique_ptr<LwwRegister<int>> engine_;
+};

[Kevin M, 2016/10/19 17:49:11]

DISALLOW_COPY_AND_ASSIGN

[steimel, 2016/10/20 00:30:07]

Done.

+
+// Takes a changeset from |from_lww_register| and applies it to
+// |to_lww_register|.
+void LwwRegisterTest::Sync(LwwRegister<int>* from_lww_register,
+                           LwwRegister<int>* to_lww_register,
+                           VersionVector from,
+                           VersionVector to) {
+  // Create a changeset from |from_lww_register|.
+  std::string changeset;
+  google::protobuf::io::StringOutputStream raw_output_stream(&changeset);
+  google::protobuf::io::CodedOutputStream output_stream(&raw_output_stream);
+  from_lww_register->CreateChangesetToCurrent(from.Invert(), &output_stream);

[scf, 2016/10/19 17:23:03]

do you need to invert here? i thought it was just remote

[steimel, 2016/10/19 17:37:54]

Yep. |from| comes from |to_lww_register|, and so it needs to be inverted when
handed to |from_lww_register|.

+
+  // Apply the changeset to |to_lww_register|.
+  google::protobuf::io::ArrayInputStream raw_input_stream(changeset.data(),
+                                                          changeset.size());
+  google::protobuf::io::CodedInputStream input_stream(&raw_input_stream);
+  to_lww_register->ApplyChangeset(from, to.Invert(), &input_stream);
+}
+
+TEST_F(LwwRegisterTest, SetIncrementsLocalVersion) {
+  Initialize(Peer::Client);
+
+  VersionVector earlier_version = client_gen_.current();
+  client_->Set(42);
+  VersionVector current_version = client_gen_.current();
+
+  EXPECT_EQ(42, client_->Get());
+  EXPECT_LT(earlier_version.local_revision(), current_version.local_revision());
+  EXPECT_TRUE(client_->ModifiedSince(earlier_version));
+  EXPECT_FALSE(client_->ModifiedSince(current_version));
+}
+
+TEST_F(LwwRegisterTest, ApplyLaterChangeset) {
+  Initialize(Peer::Client);
+
+  client_->Set(123);
+  SyncFromClient();
+
+  EXPECT_EQ(123, engine_->Get());
+}
+
+TEST_F(LwwRegisterTest, ApplyEarlierChangeset) {
+  Initialize(Peer::Client);
+
+  client_->Set(123);
+  SyncFromClient();
+
+  engine_->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(456, engine_->Get());
+}
+
+TEST_F(LwwRegisterTest, ClientApplyChangesetConflictClientWins) {
+  Initialize(Peer::Client);
+
+  client_->Set(123);
+  engine_->Set(456);
+  SyncFromEngine();
+
+  EXPECT_EQ(123, client_->Get());
+}
+
+TEST_F(LwwRegisterTest, EngineApplyChangesetConflictClientWins) {
+  Initialize(Peer::Client);
+
+  client_->Set(123);
+  engine_->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(123, engine_->Get());
+}
+
+TEST_F(LwwRegisterTest, ClientApplyChangesetConflictEngineWins) {
+  Initialize(Peer::Engine);
+
+  client_->Set(123);
+  engine_->Set(456);
+  SyncFromEngine();
+
+  EXPECT_EQ(456, client_->Get());
+}
+
+TEST_F(LwwRegisterTest, EngineApplyChangesetConflictEngineWins) {
+  Initialize(Peer::Engine);
+
+  client_->Set(123);
+  engine_->Set(456);
+  SyncFromClient();
+
+  EXPECT_EQ(456, engine_->Get());
+}
+

[Kevin M, 2016/10/19 17:49:11]

Clean tests!

[steimel, 2016/10/20 00:30:07]

Thanks!

+}  // namespace
+}  // namespace helium
+}  // namespace blimp