Make test failures in numeric transforms tests easier to read

Previously, if the value was of the wrong type, you'd get a message like:

    Value of: snap.Get("sum").is_integer()
      Actual: false
    Expected: true

Which would give no indication of what the actual type or value was. Now tests
will fail like this:

   Expected equality of these values:
     snap.Get("sum")
       Which is: 1337 (Type::kDouble)
     FieldValue::Integer(value)
       Which is: 1337 (Type::kInteger)

As an added bonus this also simplifies the calling code because now we can just
assert that a value in a snapshot is equal to some expected value and
GoogleTest will do the heavy lifting of printing the differences.

One unsolved problem with this approach is how to handle equality within
epsilon for floating point values. This turns out to be non-trivial without
writing custom matchers, which is beyond the scope of what I wanted to tackle
here. Instead of solving this I've changed the tests to use values that have an
exact representation as doubles. This is easier to do for integral values than
for fractional ones so the tests now use integer-valued doubles to achieve the
same effect of cumulative addition as before.

PiperOrigin-RevId: 321022746

Author: wilhuff

firestore/src/tests/numeric_transforms_test.cc

@@ -9,8 +9,59 @@
 namespace firebase {
 namespace firestore {
 
+using Type = FieldValue::Type;
+
 using ServerTimestampBehavior = DocumentSnapshot::ServerTimestampBehavior;
 
+const char* TypeName(Type type) {
+  switch (type) {
+    case Type::kNull:
+      return "kNull";
+    case Type::kBoolean:
+      return "kBoolean";
+    case Type::kInteger:
+      return "kInteger";
+    case Type::kDouble:
+      return "kDouble";
+    case Type::kTimestamp:
+      return "kTimestamp";
+    case Type::kString:
+      return "kString";
+    case Type::kBlob:
+      return "kBlob";
+    case Type::kReference:
+      return "kReference";
+    case Type::kGeoPoint:
+      return "kGeoPoint";
+    case Type::kArray:
+      return "kArray";
+    case Type::kMap:
+      return "kMap";
+    case Type::kDelete:
+      return "kDelete";
+    case Type::kServerTimestamp:
+      return "kServerTimestamp";
+    case Type::kArrayUnion:
+      return "kArrayUnion";
+    case Type::kArrayRemove:
+      return "kArrayRemove";
+    case Type::kIncrementInteger:
+      return "kIncrementInteger";
+    case Type::kIncrementDouble:
+      return "kIncrementDouble";
+  }
+}
+
+void PrintTo(const Type& type, std::ostream* os) {
+  *os << "Type::" << TypeName(type);
+}
+
+void PrintTo(const FieldValue& f, std::ostream* os) {
+  *os << f.ToString() << " (";
+  PrintTo(f.type(), os);
+  *os << ")";
+}
+
 class NumericTransformsTest : public FirestoreIntegrationTest {
  public:
   NumericTransformsTest() {
@@ -35,20 +86,16 @@ class NumericTransformsTest : public FirestoreIntegrationTest {
 
   void ExpectLocalAndRemoteValue(int value) {
     DocumentSnapshot snap = accumulator_.AwaitLocalEvent();
-    EXPECT_TRUE(snap.Get("sum").is_integer());
-    EXPECT_EQ(value, snap.Get("sum").integer_value());
+    ASSERT_EQ(snap.Get("sum"), FieldValue::Integer(value));
     snap = accumulator_.AwaitRemoteEvent();
-    EXPECT_TRUE(snap.Get("sum").is_integer());
-    EXPECT_EQ(value, snap.Get("sum").integer_value());
+    ASSERT_EQ(snap.Get("sum"), FieldValue::Integer(value));
   }
 
   void ExpectLocalAndRemoteValue(double value) {
     DocumentSnapshot snap = accumulator_.AwaitLocalEvent();
-    EXPECT_TRUE(snap.Get("sum").is_double());
-    EXPECT_DOUBLE_EQ(value, snap.Get("sum").double_value());
+    ASSERT_EQ(snap.Get("sum"), FieldValue::Double(value));
     snap = accumulator_.AwaitRemoteEvent();
-    EXPECT_TRUE(snap.Get("sum").is_double());
-    EXPECT_DOUBLE_EQ(value, snap.Get("sum").double_value());
+    ASSERT_EQ(snap.Get("sum"), FieldValue::Double(value));
   }
 
   // A document reference to read and write.
@@ -85,27 +132,27 @@ TEST_F(NumericTransformsTest, IntegerIncrementWithExistingInteger) {
 }
 
 TEST_F(NumericTransformsTest, DoubleIncrementWithExistingDouble) {
-  WriteInitialData({{"sum", FieldValue::Double(13.37)}});
+  WriteInitialData({{"sum", FieldValue::Double(0.5)}});
 
-  Await(doc_ref_.Update({{"sum", FieldValue::Increment(0.1)}}));
+  Await(doc_ref_.Update({{"sum", FieldValue::Increment(0.25)}}));
 
-  ExpectLocalAndRemoteValue(13.47);
+  ExpectLocalAndRemoteValue(0.75);
 }
 
 TEST_F(NumericTransformsTest, IntegerIncrementWithExistingDouble) {
-  WriteInitialData({{"sum", FieldValue::Double(13.37)}});
+  WriteInitialData({{"sum", FieldValue::Double(0.5)}});
 
   Await(doc_ref_.Update({{"sum", FieldValue::Increment(1)}}));
 
-  ExpectLocalAndRemoteValue(14.37);
+  ExpectLocalAndRemoteValue(1.5);
 }
 
 TEST_F(NumericTransformsTest, DoubleIncrementWithExistingInteger) {
-  WriteInitialData({{"sum", FieldValue::Integer(1337)}});
+  WriteInitialData({{"sum", FieldValue::Integer(1)}});
 
-  Await(doc_ref_.Update({{"sum", FieldValue::Increment(0.1)}}));
+  Await(doc_ref_.Update({{"sum", FieldValue::Increment(0.5)}}));
 
-  ExpectLocalAndRemoteValue(1337.1);
+  ExpectLocalAndRemoteValue(1.5);
 }
 
 TEST_F(NumericTransformsTest, IntegerIncrementWithExistingString) {
@@ -119,37 +166,34 @@ TEST_F(NumericTransformsTest, IntegerIncrementWithExistingString) {
 TEST_F(NumericTransformsTest, DoubleIncrementWithExistingString) {
   WriteInitialData({{"sum", FieldValue::String("overwrite")}});
 
-  Await(doc_ref_.Update({{"sum", FieldValue::Increment(13.37)}}));
+  Await(doc_ref_.Update({{"sum", FieldValue::Increment(1.5)}}));
 
-  ExpectLocalAndRemoteValue(13.37);
+  ExpectLocalAndRemoteValue(1.5);
 }
 
 TEST_F(NumericTransformsTest, MultipleDoubleIncrements) {
   WriteInitialData({{"sum", FieldValue::Double(0.0)}});
 
   DisableNetwork();
 
-  doc_ref_.Update({{"sum", FieldValue::Increment(0.1)}});
-  doc_ref_.Update({{"sum", FieldValue::Increment(0.01)}});
-  doc_ref_.Update({{"sum", FieldValue::Increment(0.001)}});
+  doc_ref_.Update({{"sum", FieldValue::Increment(0.5)}});
+  doc_ref_.Update({{"sum", FieldValue::Increment(1.0)}});
+  doc_ref_.Update({{"sum", FieldValue::Increment(2.0)}});
 
   DocumentSnapshot snap = accumulator_.AwaitLocalEvent();
 
-  EXPECT_TRUE(snap.Get("sum").is_double());
-  EXPECT_DOUBLE_EQ(0.1, snap.Get("sum").double_value());
+  EXPECT_EQ(snap.Get("sum"), FieldValue::Double(0.5));
 
   snap = accumulator_.AwaitLocalEvent();
-  EXPECT_TRUE(snap.Get("sum").is_double());
-  EXPECT_DOUBLE_EQ(0.11, snap.Get("sum").double_value());
+  EXPECT_EQ(snap.Get("sum"), FieldValue::Double(1.5));
 
   snap = accumulator_.AwaitLocalEvent();
-  EXPECT_TRUE(snap.Get("sum").is_double());
-  EXPECT_DOUBLE_EQ(0.111, snap.Get("sum").double_value());
+  EXPECT_EQ(snap.Get("sum"), FieldValue::Double(3.5));
 
   EnableNetwork();
 
   snap = accumulator_.AwaitRemoteEvent();
-  EXPECT_DOUBLE_EQ(0.111, snap.Get("sum").double_value());
+  EXPECT_EQ(snap.Get("sum"), FieldValue::Double(3.5));
 }
 
 TEST_F(NumericTransformsTest, IncrementTwiceInABatch) {
@@ -186,12 +230,12 @@ TEST_F(NumericTransformsTest, ServerTimestampAndIncrement) {
   doc_ref_.Set({{"sum", FieldValue::Increment(1)}});
 
   DocumentSnapshot snapshot = accumulator_.AwaitLocalEvent();
-  EXPECT_TRUE(
-      snapshot.Get("sum", ServerTimestampBehavior::kEstimate).is_timestamp());
+  EXPECT_EQ(snapshot.Get("sum", ServerTimestampBehavior::kEstimate).type(),
+            Type::kTimestamp);
 
   DocumentSnapshot snap = accumulator_.AwaitLocalEvent();
   EXPECT_TRUE(snap.Get("sum").is_integer());
-  EXPECT_EQ(1, snap.Get("sum").integer_value());
+  EXPECT_EQ(snap.Get("sum"), FieldValue::Integer(1));
 
   EnableNetwork();