Add ObjectValue::Map alias (#967)

3 files changed, 36 insertions, 38 deletions

diff --git a/Firestore/core/test/firebase/firestore/model/document_test.cc b/Firestore/core/test/firebase/firestore/model/document_test.cc
index 6b72360..066c875 100644
--- a/Firestore/core/test/firebase/firestore/model/document_test.cc
+++ b/Firestore/core/test/firebase/firestore/model/document_test.cc
@@ -29,7 +29,7 @@ inline Document MakeDocument(const absl::string_view data,
                              const absl::string_view path,
                              const Timestamp& timestamp,
                              bool has_local_mutations) {
-  return Document(FieldValue::ObjectValue(
+  return Document(FieldValue::ObjectValueFromMap(
                       {{"field", FieldValue::StringValue(data.data())}}),
                   DocumentKey::FromPathString(path.data()),
                   SnapshotVersion(timestamp), has_local_mutations);
@@ -41,9 +41,9 @@ TEST(Document, Getter) {
   const Document& doc =
       MakeDocument("foo", "i/am/a/path", Timestamp(123, 456), true);
   EXPECT_EQ(MaybeDocument::Type::Document, doc.type());
-  EXPECT_EQ(
-      FieldValue::ObjectValue({{"field", FieldValue::StringValue("foo")}}),
-      doc.data());
+  EXPECT_EQ(FieldValue::ObjectValueFromMap(
+                {{"field", FieldValue::StringValue("foo")}}),
+            doc.data());
   EXPECT_EQ(DocumentKey::FromPathString("i/am/a/path"), doc.key());
   EXPECT_EQ(SnapshotVersion(Timestamp(123, 456)), doc.version());
   EXPECT_TRUE(doc.has_local_mutations());
@@ -64,7 +64,7 @@ TEST(Document, Comparison) {
 
   // Document and MaybeDocument will not equal. In particular, Document and
   // NoDocument will not equal, which I won't test here.
-  EXPECT_NE(Document(FieldValue::ObjectValue({}),
+  EXPECT_NE(Document(FieldValue::ObjectValueFromMap({}),
                      DocumentKey::FromPathString("same/path"),
                      SnapshotVersion(Timestamp()), false),
             MaybeDocument(DocumentKey::FromPathString("same/path"),
diff --git a/Firestore/core/test/firebase/firestore/model/field_value_test.cc b/Firestore/core/test/firebase/firestore/model/field_value_test.cc
index 93879f9..40be2d5 100644
--- a/Firestore/core/test/firebase/firestore/model/field_value_test.cc
+++ b/Firestore/core/test/firebase/firestore/model/field_value_test.cc
@@ -189,17 +189,17 @@ TEST(FieldValue, ArrayType) {
 }
 
 TEST(FieldValue, ObjectType) {
-  const FieldValue empty =
-      FieldValue::ObjectValue(std::map<std::string, FieldValue>{});
-  std::map<std::string, FieldValue> object{{"null", FieldValue::NullValue()},
-                                           {"true", FieldValue::TrueValue()},
-                                           {"false", FieldValue::FalseValue()}};
+  const FieldValue empty = FieldValue::ObjectValueFromMap({});
+  ObjectValue::Map object{{"null", FieldValue::NullValue()},
+                          {"true", FieldValue::TrueValue()},
+                          {"false", FieldValue::FalseValue()}};
   // copy the map
-  const FieldValue small = FieldValue::ObjectValue(object);
-  std::map<std::string, FieldValue> another_object{
-      {"null", FieldValue::NullValue()}, {"true", FieldValue::FalseValue()}};
+  const FieldValue small = FieldValue::ObjectValueFromMap(object);
+  ObjectValue::Map another_object{{"null", FieldValue::NullValue()},
+                                  {"true", FieldValue::FalseValue()}};
   // move the array
-  const FieldValue large = FieldValue::ObjectValue(std::move(another_object));
+  const FieldValue large =
+      FieldValue::ObjectValueFromMap(std::move(another_object));
   EXPECT_EQ(Type::Object, empty.type());
   EXPECT_EQ(Type::Object, small.type());
   EXPECT_EQ(Type::Object, large.type());
@@ -335,22 +335,22 @@ TEST(FieldValue, Copy) {
   clone = null_value;
   EXPECT_EQ(FieldValue::NullValue(), clone);
 
-  const FieldValue object_value = FieldValue::ObjectValue(
-      std::map<std::string, FieldValue>{{"true", FieldValue::TrueValue()},
-                                        {"false", FieldValue::FalseValue()}});
+  const FieldValue object_value = FieldValue::ObjectValueFromMap(
+      ObjectValue::Map{{"true", FieldValue::TrueValue()},
+                       {"false", FieldValue::FalseValue()}});
   clone = object_value;
-  EXPECT_EQ(FieldValue::ObjectValue(std::map<std::string, FieldValue>{
-                {"true", FieldValue::TrueValue()},
-                {"false", FieldValue::FalseValue()}}),
+  EXPECT_EQ(FieldValue::ObjectValueFromMap(
+                ObjectValue::Map{{"true", FieldValue::TrueValue()},
+                                 {"false", FieldValue::FalseValue()}}),
             clone);
-  EXPECT_EQ(FieldValue::ObjectValue(std::map<std::string, FieldValue>{
-                {"true", FieldValue::TrueValue()},
-                {"false", FieldValue::FalseValue()}}),
+  EXPECT_EQ(FieldValue::ObjectValueFromMap(
+                ObjectValue::Map{{"true", FieldValue::TrueValue()},
+                                 {"false", FieldValue::FalseValue()}}),
             object_value);
   clone = clone;
-  EXPECT_EQ(FieldValue::ObjectValue(std::map<std::string, FieldValue>{
-                {"true", FieldValue::TrueValue()},
-                {"false", FieldValue::FalseValue()}}),
+  EXPECT_EQ(FieldValue::ObjectValueFromMap(
+                ObjectValue::Map{{"true", FieldValue::TrueValue()},
+                                 {"false", FieldValue::FalseValue()}}),
             clone);
   clone = null_value;
   EXPECT_EQ(FieldValue::NullValue(), clone);
@@ -430,13 +430,12 @@ TEST(FieldValue, Move) {
   clone = FieldValue::NullValue();
   EXPECT_EQ(FieldValue::NullValue(), clone);
 
-  FieldValue object_value = FieldValue::ObjectValue(
-      std::map<std::string, FieldValue>{{"true", FieldValue::TrueValue()},
-                                        {"false", FieldValue::FalseValue()}});
+  FieldValue object_value = FieldValue::ObjectValueFromMap(ObjectValue::Map{
+      {"true", FieldValue::TrueValue()}, {"false", FieldValue::FalseValue()}});
   clone = std::move(object_value);
-  EXPECT_EQ(FieldValue::ObjectValue(std::map<std::string, FieldValue>{
-                {"true", FieldValue::TrueValue()},
-                {"false", FieldValue::FalseValue()}}),
+  EXPECT_EQ(FieldValue::ObjectValueFromMap(
+                ObjectValue::Map{{"true", FieldValue::TrueValue()},
+                                 {"false", FieldValue::FalseValue()}}),
             clone);
   clone = FieldValue::NullValue();
   EXPECT_EQ(FieldValue::NullValue(), clone);
@@ -455,8 +454,7 @@ TEST(FieldValue, CompareMixedType) {
   const FieldValue geo_point_value = FieldValue::GeoPointValue({1, 2});
   const FieldValue array_value =
       FieldValue::ArrayValue(std::vector<FieldValue>());
-  const FieldValue object_value =
-      FieldValue::ObjectValue(std::map<std::string, FieldValue>());
+  const FieldValue object_value = FieldValue::ObjectValueFromMap({});
   EXPECT_TRUE(null_value < true_value);
   EXPECT_TRUE(true_value < number_value);
   EXPECT_TRUE(number_value < timestamp_value);
diff --git a/Firestore/core/test/firebase/firestore/remote/serializer_test.cc b/Firestore/core/test/firebase/firestore/remote/serializer_test.cc
index e2456d5..862ac97 100644
--- a/Firestore/core/test/firebase/firestore/remote/serializer_test.cc
+++ b/Firestore/core/test/firebase/firestore/remote/serializer_test.cc
@@ -194,7 +194,7 @@ TEST_F(SerializerTest, WritesStringModelToBytes) {
 }
 
 TEST_F(SerializerTest, WritesEmptyMapToBytes) {
-  FieldValue model = FieldValue::ObjectValue({});
+  FieldValue model = FieldValue::ObjectValueFromMap({});
   // TEXT_FORMAT_PROTO: 'map_value: {}'
   std::vector<uint8_t> bytes{0x32, 0x00};
   ExpectRoundTrip(model, bytes, FieldValue::Type::Object);
@@ -206,7 +206,7 @@ TEST_F(SerializerTest, WritesNestedObjectsToBytes) {
   // TODO(rsgowman): link libprotobuf to the test suite and eliminate the
   // above.
 
-  FieldValue model = FieldValue::ObjectValue(
+  FieldValue model = FieldValue::ObjectValueFromMap(
       {{"b", FieldValue::TrueValue()},
        // TODO(rsgowman): add doubles (once they're supported)
        // {"d", FieldValue::DoubleValue(std::numeric_limits<double>::max())},
@@ -215,10 +215,10 @@ TEST_F(SerializerTest, WritesNestedObjectsToBytes) {
        {"s", FieldValue::StringValue("foo")},
        // TODO(rsgowman): add arrays (once they're supported)
        // {"a", [2, "bar", {"b", false}]},
-       {"o", FieldValue::ObjectValue(
+       {"o", FieldValue::ObjectValueFromMap(
                  {{"d", FieldValue::IntegerValue(100)},
                   {"nested",
-                   FieldValue::ObjectValue(
+                   FieldValue::ObjectValueFromMap(
                        {{"e", FieldValue::IntegerValue(
                                   std::numeric_limits<int64_t>::max())}})}})}});