operator== and operator!= for DocumentChange.

Author: ehsannas

firestore/integration_test_internal/src/document_change_test.cc

@@ -13,10 +13,10 @@
 namespace firebase {
 namespace firestore {
 
-#if defined(__ANDROID__)
-
 using DocumentChangeTest = FirestoreIntegrationTest;
 
+#if defined(__ANDROID__)
+
 TEST_F(DocumentChangeTest, Construction) {
   testutil::AssertWrapperConstructionContract<DocumentChange,
                                               DocumentChangeInternal>();
@@ -78,5 +78,67 @@ TEST_F(DocumentChangeTest, TestDocumentChanges) {
 
 #endif  // defined(__ANDROID__)
 
+TEST_F(DocumentChangeTest, Equality) {
+  DocumentChange invalid_change_1 = DocumentChange();
+  DocumentChange invalid_change_2 = DocumentChange();
+
+  EXPECT_TRUE(invalid_change_1 == invalid_change_2);
+  EXPECT_FALSE(invalid_change_1 != invalid_change_2);
+
+  CollectionReference collection = Collection();
+  Query query = collection.OrderBy("a");
+
+  DocumentReference doc1 = collection.Document("1");
+  DocumentReference doc2 = collection.Document("2");
+
+  TestEventListener<QuerySnapshot> listener("TestDocumentChanges");
+  ListenerRegistration registration = listener.AttachTo(&query);
+  Await(listener);
+  QuerySnapshot snapshot = listener.last_result();
+  EXPECT_EQ(snapshot.size(), 0);
+
+  WriteDocument(doc1, MapFieldValue{{"a", FieldValue::Integer(1)}});
+  Await(listener);
+  snapshot = listener.last_result();
+
+  std::vector<DocumentChange> changes = snapshot.DocumentChanges();
+  EXPECT_EQ(changes.size(), 1);
+  // first_change: Added doc1.
+  auto first_change = changes[0];
+  EXPECT_TRUE(first_change == first_change);
+  EXPECT_TRUE(first_change != invalid_change_1);
+  EXPECT_FALSE(first_change != first_change);
+  EXPECT_FALSE(first_change == invalid_change_1);
+
+  WriteDocument(doc2, MapFieldValue{{"a", FieldValue::Integer(2)}});
+  Await(listener, 2);
+  snapshot = listener.last_result();
+
+  changes = snapshot.DocumentChanges();
+  EXPECT_EQ(changes.size(), 1);
+  // second_change: Added doc2.
+  auto second_change = changes[0];
+  EXPECT_TRUE(second_change != first_change);
+  EXPECT_TRUE(second_change != invalid_change_1);
+  EXPECT_FALSE(second_change == first_change);
+  EXPECT_FALSE(second_change == invalid_change_1);
+
+  // Make doc2 ordered before doc1.
+  WriteDocument(doc2, MapFieldValue{{"a", FieldValue::Integer(0)}});
+  Await(listener, 3);
+  snapshot = listener.last_result();
+
+  changes = snapshot.DocumentChanges();
+  EXPECT_EQ(changes.size(), 1);
+  // third_change: Modified doc2.
+  auto third_change = changes[0];
+  EXPECT_TRUE(third_change != first_change);
+  EXPECT_TRUE(third_change != second_change);
+  EXPECT_TRUE(third_change != invalid_change_1);
+  EXPECT_FALSE(third_change == first_change);
+  EXPECT_FALSE(third_change == second_change);
+  EXPECT_FALSE(third_change == invalid_change_1);
+}
+
 }  // namespace firestore
 }  // namespace firebase

firestore/src/common/document_change.cc

@@ -104,5 +104,10 @@ std::size_t DocumentChange::new_index() const {
   return internal_->new_index();
 }
 
+bool operator==(const DocumentChange& lhs, const DocumentChange& rhs) {
+  return lhs.type() == rhs.type() && lhs.old_index() == rhs.old_index() &&
+         lhs.new_index() == rhs.new_index() && lhs.document() == rhs.document();
+}
+
 }  // namespace firestore
 }  // namespace firebase

firestore/src/include/firebase/firestore/document_change.h

@@ -184,6 +184,14 @@ class DocumentChange {
   mutable DocumentChangeInternal* internal_ = nullptr;
 };
 
+/** Checks `lhs` and `rhs` for equality. */
+bool operator==(const DocumentChange& lhs, const DocumentChange& rhs);
+
+/** Checks `lhs` and `rhs` for inequality. */
+inline bool operator!=(const DocumentChange& lhs, const DocumentChange& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace firestore
 }  // namespace firebase