react-native-windows 0.81.34 → 0.81.37

package/external/folly/folly/json/test/DynamicTest.cpp

@@ -0,0 +1,1647 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/json/dynamic.h>
+
+#include <cmath>
+#include <iterator>
+
+#include <glog/logging.h>
+
+#include <folly/Range.h>
+#include <folly/hash/Hash.h>
+#include <folly/json/json.h>
+#include <folly/portability/GTest.h>
+#include <folly/test/ComparisonOperatorTestUtil.h>
+
+namespace folly {
+namespace test {
+
+using namespace detail;
+
+TEST(Dynamic, Default) {
+  dynamic obj;
+  EXPECT_TRUE(obj.isNull());
+}
+
+TEST(Dynamic, ObjectBasics) {
+  dynamic obj = dynamic::object("a", false);
+  EXPECT_EQ(obj.at("a"), false);
+  EXPECT_EQ(obj.size(), 1);
+  obj.insert("a", true);
+
+  dynamic key{"a"};
+  folly::StringPiece sp{"a"};
+  std::string s{"a"};
+
+  EXPECT_EQ(obj.size(), 1);
+  EXPECT_EQ(obj.at("a"), true);
+  EXPECT_EQ(obj.at(sp), true);
+  EXPECT_EQ(obj.at(key), true);
+
+  obj.at(sp) = nullptr;
+  EXPECT_EQ(obj.size(), 1);
+  EXPECT_TRUE(obj.at(s) == nullptr);
+
+  obj["a"] = 12;
+  EXPECT_EQ(obj[sp], 12);
+  obj[key] = "foo";
+  EXPECT_EQ(obj["a"], "foo");
+  (void)obj["b"];
+  EXPECT_EQ(obj.size(), 2);
+
+  obj.erase("a");
+  EXPECT_TRUE(obj.find(sp) == obj.items().end());
+  obj.erase("b");
+  EXPECT_EQ(obj.size(), 0);
+
+  dynamic newObject = dynamic::object;
+
+  newObject["z"] = 12;
+  EXPECT_EQ(newObject.size(), 1);
+  newObject["a"] = true;
+  EXPECT_EQ(newObject.size(), 2);
+
+  EXPECT_EQ(*newObject.keys().begin(), newObject.items().begin()->first);
+  EXPECT_EQ(*newObject.values().begin(), newObject.items().begin()->second);
+  std::vector<std::pair<std::string, dynamic>> found;
+  found.emplace_back(
+      newObject.keys().begin()->asString(), *newObject.values().begin());
+
+  EXPECT_EQ(
+      *std::next(newObject.keys().begin()),
+      std::next(newObject.items().begin())->first);
+  EXPECT_EQ(
+      *std::next(newObject.values().begin()),
+      std::next(newObject.items().begin())->second);
+  found.emplace_back(
+      std::next(newObject.keys().begin())->asString(),
+      *std::next(newObject.values().begin()));
+
+  std::sort(found.begin(), found.end());
+
+  EXPECT_EQ("a", found[0].first);
+  EXPECT_TRUE(found[0].second.asBool());
+
+  EXPECT_EQ("z", found[1].first);
+  EXPECT_EQ(12, found[1].second.asInt());
+
+  dynamic obj2 = dynamic::object;
+  EXPECT_TRUE(obj2.isObject());
+
+  dynamic obj3 = dynamic::object("a", false);
+  EXPECT_EQ(obj3.at("a"), false);
+  EXPECT_EQ(obj3.size(), 1);
+  {
+    const auto [it, inserted] = obj3.emplace("a", true);
+    EXPECT_EQ(obj3.size(), 1);
+    EXPECT_FALSE(inserted);
+    EXPECT_EQ(it->second, false);
+  }
+  {
+    const auto [it, inserted] = obj3.emplace("b", true);
+    EXPECT_EQ(obj3.size(), 2);
+    EXPECT_TRUE(inserted);
+    EXPECT_EQ(it->second, true);
+  }
+  {
+    const auto [it, inserted] = obj3.try_emplace("a", true);
+    EXPECT_EQ(obj3.size(), 2);
+    EXPECT_FALSE(inserted);
+    EXPECT_EQ(it->second, false);
+  }
+  {
+    const auto [it, inserted] = obj3.try_emplace("c", true);
+    EXPECT_EQ(obj3.size(), 3);
+    EXPECT_TRUE(inserted);
+    EXPECT_EQ(it->second, true);
+  }
+
+  dynamic d3 = nullptr;
+  EXPECT_TRUE(d3 == nullptr);
+  d3 = dynamic::object;
+  EXPECT_TRUE(d3.isObject());
+  d3["foo"] = dynamic::array(1, 2, 3);
+  EXPECT_EQ(d3.count("foo"), 1);
+
+  d3[123] = 321;
+  EXPECT_EQ(d3.at(123), 321);
+
+  d3["123"] = 42;
+  EXPECT_EQ(d3.at("123"), 42);
+  EXPECT_EQ(d3.at(123), 321);
+
+  dynamic objInsert = folly::dynamic::object();
+  dynamic objA = folly::dynamic::object("1", "2");
+  dynamic objB = folly::dynamic::object("1", "2");
+
+  objInsert.insert("1", std::move(objA));
+  objInsert.insert("1", std::move(objB));
+
+  EXPECT_EQ(objInsert.find("1")->second.size(), 1);
+
+  // Looking up objects as keys
+  // clang-format off
+  dynamic objDefinedInOneOrder = folly::dynamic::object
+    ("bar", "987")
+    ("baz", folly::dynamic::array(1, 2, 3))
+    ("foo2", folly::dynamic::object("1", "2"));
+  dynamic sameObjInDifferentOrder = folly::dynamic::object
+    ("bar", "987")
+    ("foo2", folly::dynamic::object("1", "2"))
+    ("baz", folly::dynamic::array(1, 2, 3));
+  // clang-format on
+
+  newObject[objDefinedInOneOrder] = 12;
+  EXPECT_EQ(newObject.at(objDefinedInOneOrder).getInt(), 12);
+  EXPECT_EQ(newObject.at(sameObjInDifferentOrder).getInt(), 12);
+
+  // Merge two objects
+  dynamic origMergeObj1 = folly::dynamic::object();
+  // clang-format off
+  dynamic mergeObj1 = origMergeObj1 = folly::dynamic::object
+    ("key1", "value1")
+    ("key2", "value2");
+  dynamic mergeObj2 = folly::dynamic::object
+    ("key2", "value3")
+    ("key3", "value4");
+  // clang-format on
+
+  // Merged object where we prefer the values in mergeObj2
+  // clang-format off
+  dynamic combinedPreferObj2 = folly::dynamic::object
+    ("key1", "value1")
+    ("key2", "value3")
+    ("key3", "value4");
+  // clang-format on
+
+  // Merged object where we prefer the values in mergeObj1
+  // clang-format off
+  dynamic combinedPreferObj1 = folly::dynamic::object
+    ("key1", "value1")
+    ("key2", "value2")
+    ("key3", "value4");
+  // clang-format on
+
+  auto newMergeObj = dynamic::merge(mergeObj1, mergeObj2);
+  EXPECT_EQ(newMergeObj, combinedPreferObj2);
+  EXPECT_EQ(mergeObj1, origMergeObj1); // mergeObj1 should be unchanged
+
+  mergeObj1.update(mergeObj2);
+  EXPECT_EQ(mergeObj1, combinedPreferObj2);
+  dynamic arr = dynamic::array(1, 2, 3, 4, 5, 6);
+  EXPECT_THROW(mergeObj1.update(arr), std::exception);
+
+  mergeObj1 = origMergeObj1; // reset it
+  mergeObj1.update_missing(mergeObj2);
+  EXPECT_EQ(mergeObj1, combinedPreferObj1);
+}
+
+TEST(Dynamic, ArrayInsertErase) {
+  auto arr = dynamic::array(1, 2, 3, 4, 5, 6);
+
+  arr.erase(arr.begin() + 3);
+  EXPECT_EQ(5, arr[3].asInt());
+
+  arr.insert(arr.begin() + 3, 4);
+  EXPECT_EQ(4, arr[3].asInt());
+  EXPECT_EQ(5, arr[4].asInt());
+
+  auto x = dynamic::array(55, 66);
+  arr.insert(arr.begin() + 4, std::move(x));
+  EXPECT_EQ(55, arr[4][0].asInt());
+  EXPECT_EQ(66, arr[4][1].asInt());
+  EXPECT_EQ(5, arr[5].asInt());
+
+  dynamic obj = dynamic::object;
+  obj.insert(3, 4);
+  EXPECT_EQ(4, obj[3].asInt());
+}
+
+TEST(Dynamic, ArrayInsertRange) {
+  {
+    auto arr = dynamic::array(1, 2, 3);
+    auto extend = dynamic::array(4, 5);
+    arr.insert(arr.end(), extend.begin(), extend.end());
+    EXPECT_EQ(5, arr.size());
+    EXPECT_EQ(4, arr[3].asInt());
+    EXPECT_EQ(5, arr[4].asInt());
+  }
+  {
+    auto arr = dynamic::array(1, 4, 5);
+    auto extend = dynamic::array(2, 3);
+    arr.insert(arr.begin() + 1, extend.begin(), extend.end());
+    EXPECT_EQ(5, arr.size());
+    EXPECT_EQ(1, arr[0].asInt());
+    EXPECT_EQ(2, arr[1].asInt());
+    EXPECT_EQ(3, arr[2].asInt());
+    EXPECT_EQ(4, arr[3].asInt());
+  }
+  {
+    auto arr = dynamic::array(1, 2, 3);
+    auto extend = dynamic::array("a", "b");
+    arr.insert(arr.end(), extend.begin(), extend.end());
+    EXPECT_EQ(5, arr.size());
+    EXPECT_EQ("a", arr[3].asString());
+    EXPECT_EQ("b", arr[4].asString());
+  }
+}
+
+TEST(Dynamic, ArrayRangeConstruct) {
+  {
+    std::vector nums{0, 1, 2, 3};
+    auto arr =
+        dynamic(dynamic::array_range_construct, nums.begin(), nums.end());
+    EXPECT_EQ(nums.size(), arr.size());
+    for (size_t i = 0; i < nums.size(); ++i) {
+      EXPECT_EQ(nums[i], arr[i].asInt());
+    }
+  }
+  {
+    std::vector nums{0, 1, 2, 3};
+    auto arr = dynamic(dynamic::array_range_construct, nums);
+    EXPECT_EQ(nums.size(), arr.size());
+    for (size_t i = 0; i < nums.size(); ++i) {
+      EXPECT_EQ(nums[i], arr[i].asInt());
+    }
+  }
+}
+
+TEST(Dynamic, ArrayRangeFactory) {
+  {
+    std::vector nums{0, 1, 2, 3};
+    auto arr = dynamic::array_range(nums.begin(), nums.end());
+    EXPECT_EQ(nums.size(), arr.size());
+    for (size_t i = 0; i < nums.size(); ++i) {
+      EXPECT_EQ(nums[i], arr[i].asInt());
+    }
+  }
+  {
+    std::vector nums{0, 1, 2, 3};
+    auto arr = dynamic::array_range(nums);
+    EXPECT_EQ(nums.size(), arr.size());
+    for (size_t i = 0; i < nums.size(); ++i) {
+      EXPECT_EQ(nums[i], arr[i].asInt());
+    }
+  }
+}
+
+namespace {
+
+struct StaticStrings {
+  static constexpr auto kA = "a";
+  static constexpr const char* kB = "b";
+  static const folly::StringPiece kFoo;
+  static const std::string kBar;
+};
+/* static */ const folly::StringPiece StaticStrings::kFoo{"foo"};
+/* static */ const std::string StaticStrings::kBar{"bar"};
+
+} // namespace
+
+TEST(Dynamic, ObjectHeterogeneousAccess) {
+  dynamic empty;
+  dynamic foo{"foo"};
+  const char* a = "a";
+  StringPiece sp{"a"};
+  std::string str{"a"};
+  dynamic bar{"bar"};
+  const char* b = "b";
+
+  dynamic obj = dynamic::object("a", 123)(empty, 456)(foo, 789);
+
+  // at()
+  EXPECT_EQ(obj.at(empty), 456);
+  EXPECT_EQ(obj.at(nullptr), 456);
+  EXPECT_EQ(obj.at(foo), 789);
+
+  EXPECT_EQ(obj.at(a), 123);
+  EXPECT_EQ(obj.at(StaticStrings::kA), 123);
+  EXPECT_EQ(obj.at("a"), 123);
+
+  EXPECT_EQ(obj.at(sp), 123);
+  EXPECT_EQ(obj.at(StringPiece{"a"}), 123);
+  EXPECT_EQ(obj.at(StaticStrings::kFoo), 789);
+
+  EXPECT_EQ(obj.at(std::string{"a"}), 123);
+  EXPECT_EQ(obj.at(str), 123);
+
+  EXPECT_THROW(obj.at(b), std::out_of_range);
+  EXPECT_THROW(obj.at(StringPiece{b}), std::out_of_range);
+  EXPECT_THROW(obj.at(StaticStrings::kBar), std::out_of_range);
+
+  // get_ptr()
+  EXPECT_NE(obj.get_ptr(empty), nullptr);
+  EXPECT_EQ(*obj.get_ptr(empty), 456);
+  EXPECT_NE(obj.get_ptr(nullptr), nullptr);
+  EXPECT_EQ(*obj.get_ptr(nullptr), 456);
+  EXPECT_NE(obj.get_ptr(foo), nullptr);
+  EXPECT_EQ(*obj.get_ptr(foo), 789);
+
+  EXPECT_NE(obj.get_ptr(a), nullptr);
+  EXPECT_EQ(*obj.get_ptr(a), 123);
+  EXPECT_NE(obj.get_ptr(StaticStrings::kA), nullptr);
+  EXPECT_EQ(*obj.get_ptr(StaticStrings::kA), 123);
+  EXPECT_NE(obj.get_ptr("a"), nullptr);
+  EXPECT_EQ(*obj.get_ptr("a"), 123);
+
+  EXPECT_NE(obj.get_ptr(sp), nullptr);
+  EXPECT_EQ(*obj.get_ptr(sp), 123);
+  EXPECT_NE(obj.get_ptr(StringPiece{"a"}), nullptr);
+  EXPECT_EQ(*obj.get_ptr(StringPiece{"a"}), 123);
+  EXPECT_NE(obj.get_ptr(StaticStrings::kFoo), nullptr);
+  EXPECT_EQ(*obj.get_ptr(StaticStrings::kFoo), 789);
+
+  EXPECT_NE(obj.get_ptr(std::string{"a"}), nullptr);
+  EXPECT_EQ(*obj.get_ptr(std::string{"a"}), 123);
+  EXPECT_NE(obj.get_ptr(str), nullptr);
+  EXPECT_EQ(*obj.get_ptr(str), 123);
+
+  EXPECT_EQ(obj.get_ptr(b), nullptr);
+  EXPECT_EQ(obj.get_ptr(StringPiece{b}), nullptr);
+  EXPECT_EQ(obj.get_ptr(StaticStrings::kBar), nullptr);
+
+  // find()
+  EXPECT_EQ(obj.find(empty)->second, 456);
+  EXPECT_EQ(obj.find(nullptr)->second, 456);
+  EXPECT_EQ(obj.find(foo)->second, 789);
+
+  EXPECT_EQ(obj.find(a)->second, 123);
+  EXPECT_EQ(obj.find(StaticStrings::kA)->second, 123);
+  EXPECT_EQ(obj.find("a")->second, 123);
+
+  EXPECT_EQ(obj.find(sp)->second, 123);
+  EXPECT_EQ(obj.find(StringPiece{"a"})->second, 123);
+  EXPECT_EQ(obj.find(StaticStrings::kFoo)->second, 789);
+
+  EXPECT_EQ(obj.find(std::string{"a"})->second, 123);
+  EXPECT_EQ(obj.find(str)->second, 123);
+
+  EXPECT_TRUE(obj.find(b) == obj.items().end());
+  EXPECT_TRUE(obj.find(StringPiece{b}) == obj.items().end());
+  EXPECT_TRUE(obj.find(StaticStrings::kBar) == obj.items().end());
+
+  // count()
+  EXPECT_EQ(obj.count(empty), 1);
+  EXPECT_EQ(obj.count(nullptr), 1);
+  EXPECT_EQ(obj.count(foo), 1);
+
+  EXPECT_EQ(obj.count(a), 1);
+  EXPECT_EQ(obj.count(StaticStrings::kA), 1);
+  EXPECT_EQ(obj.count("a"), 1);
+
+  EXPECT_EQ(obj.count(sp), 1);
+  EXPECT_EQ(obj.count(StringPiece{"a"}), 1);
+  EXPECT_EQ(obj.count(StaticStrings::kFoo), 1);
+
+  EXPECT_EQ(obj.count(std::string{"a"}), 1);
+  EXPECT_EQ(obj.count(str), 1);
+
+  EXPECT_EQ(obj.count(b), 0);
+  EXPECT_EQ(obj.count(StringPiece{b}), 0);
+  EXPECT_EQ(obj.count(StaticStrings::kBar), 0);
+
+  // operator[]
+  EXPECT_EQ(obj[empty], 456);
+  EXPECT_EQ(obj[nullptr], 456);
+  EXPECT_EQ(obj[foo], 789);
+
+  EXPECT_EQ(obj[a], 123);
+  EXPECT_EQ(obj[StaticStrings::kA], 123);
+  EXPECT_EQ(obj["a"], 123);
+
+  EXPECT_EQ(obj[sp], 123);
+  EXPECT_EQ(obj[StringPiece{"a"}], 123);
+  EXPECT_EQ(obj[StaticStrings::kFoo], 789);
+
+  EXPECT_EQ(obj[std::string{"a"}], 123);
+  EXPECT_EQ(obj[str], 123);
+
+  EXPECT_EQ(obj[b], nullptr);
+  obj[b] = 42;
+  EXPECT_EQ(obj[StringPiece{b}], 42);
+  obj[StaticStrings::kBar] = 43;
+  EXPECT_EQ(obj["bar"], 43);
+
+  // erase() + dynamic&&
+  EXPECT_EQ(obj.erase(StaticStrings::kB), /* num elements erased */ 1);
+
+  dynamic obj2 = obj;
+  dynamic obj3 = obj;
+  dynamic obj4 = obj;
+  EXPECT_EQ(std::move(obj).find(StaticStrings::kFoo)->second, 789);
+  EXPECT_EQ(std::move(obj2).at(StaticStrings::kA), 123);
+  EXPECT_EQ(std::move(obj3)[nullptr], 456);
+  EXPECT_EQ(std::move(obj4).erase(StaticStrings::kBar), 1);
+}
+
+TEST(Dynamic, CastFromVectorOfBooleans) {
+  std::vector<bool> b;
+  b.push_back(true);
+  b.push_back(false);
+  dynamic obj = dynamic::object("a", b[0])("b", b[1]);
+  EXPECT_EQ(obj.at("a"), true);
+  EXPECT_EQ(obj.at("b"), false);
+}
+
+TEST(Dynamic, CastFromConstVectorOfBooleans) {
+  const std::vector<bool> b = {true, false};
+  dynamic obj = dynamic::object("a", b[0])("b", b[1]);
+  EXPECT_EQ(obj.at("a"), true);
+  EXPECT_EQ(obj.at("b"), false);
+}
+
+TEST(Dynamic, ObjectErase) {
+  dynamic obj = dynamic::object("key1", "val")("key2", "val2");
+  EXPECT_EQ(obj.count("key1"), 1);
+  EXPECT_EQ(obj.count("key2"), 1);
+  EXPECT_EQ(obj.erase("key1"), 1);
+  EXPECT_EQ(obj.count("key1"), 0);
+  EXPECT_EQ(obj.count("key2"), 1);
+  EXPECT_EQ(obj.erase("key1"), 0);
+  obj["key1"] = 12;
+  EXPECT_EQ(obj.count("key1"), 1);
+  EXPECT_EQ(obj.count("key2"), 1);
+  auto it = obj.find("key2");
+  obj.erase(it);
+  EXPECT_EQ(obj.count("key1"), 1);
+  EXPECT_EQ(obj.count("key2"), 0);
+
+  obj["asd"] = 42.0;
+  obj["foo"] = 42.0;
+  EXPECT_EQ(obj.size(), 3);
+  auto ret = obj.erase(std::next(obj.items().begin()), obj.items().end());
+  EXPECT_TRUE(ret == obj.items().end());
+  EXPECT_EQ(obj.size(), 1);
+  obj.erase(obj.items().begin());
+  EXPECT_TRUE(obj.empty());
+}
+
+TEST(Dynamic, ArrayErase) {
+  dynamic arr = dynamic::array(1, 2, 3, 4, 5, 6);
+
+  EXPECT_THROW(arr.erase(1), std::exception);
+  EXPECT_EQ(arr.size(), 6);
+  EXPECT_EQ(arr[0], 1);
+  arr.erase(arr.begin());
+  EXPECT_EQ(arr.size(), 5);
+
+  arr.erase(std::next(arr.begin()), std::prev(arr.end()));
+  EXPECT_EQ(arr.size(), 2);
+  EXPECT_EQ(arr[0], 2);
+  EXPECT_EQ(arr[1], 6);
+}
+
+TEST(Dynamic, StringBasics) {
+  dynamic str = "hello world";
+  EXPECT_EQ(11, str.size());
+  EXPECT_FALSE(str.empty());
+  str = "";
+  EXPECT_TRUE(str.empty());
+
+  dynamic std_str = std::string("hello world");
+  EXPECT_EQ(11, std_str.size());
+  EXPECT_FALSE(std_str.empty());
+
+  dynamic stringpiece = folly::StringPiece("hello world");
+  EXPECT_EQ(11, stringpiece.size());
+  EXPECT_FALSE(stringpiece.empty());
+
+  dynamic vectorstring = std::vector<char>{'a', 'b', 'c', 'd', 'e', 'f'};
+  EXPECT_EQ(6, vectorstring.size());
+  EXPECT_FALSE(vectorstring.empty());
+}
+
+TEST(Dynamic, ArrayBasics) {
+  dynamic array = dynamic::array(1, 2, 3);
+  EXPECT_EQ(array.size(), 3);
+  EXPECT_EQ(array.at(0), 1);
+  EXPECT_EQ(array.at(1), 2);
+  EXPECT_EQ(array.at(2), 3);
+
+  EXPECT_ANY_THROW(array.at(-1));
+  EXPECT_ANY_THROW(array.at(3));
+
+  array.push_back("foo");
+  EXPECT_EQ(array.size(), 4);
+
+  array.resize(12, "something");
+  EXPECT_EQ(array.size(), 12);
+  EXPECT_EQ(array[11], "something");
+}
+
+TEST(Dynamic, Reserve) {
+  // reserve() has no observable behavior, so we only check that it can be
+  // called on the supported types.
+  dynamic{dynamic::array}.reserve(10);
+  dynamic{dynamic::object}.reserve(10);
+  dynamic{std::string{}}.reserve(10);
+  EXPECT_THROW(dynamic{}.reserve(10), folly::TypeError);
+  EXPECT_THROW(dynamic{1}.reserve(10), folly::TypeError);
+}
+
+TEST(Dynamic, DeepCopy) {
+  dynamic val = dynamic::array("foo", "bar", dynamic::array("foo1", "bar1"));
+  EXPECT_EQ(val.at(2).at(0), "foo1");
+  EXPECT_EQ(val.at(2).at(1), "bar1");
+  dynamic val2 = val;
+  EXPECT_EQ(val2.at(2).at(0), "foo1");
+  EXPECT_EQ(val2.at(2).at(1), "bar1");
+  EXPECT_EQ(val.at(2).at(0), "foo1");
+  EXPECT_EQ(val.at(2).at(1), "bar1");
+  val2.at(2).at(0) = "foo3";
+  val2.at(2).at(1) = "bar3";
+  EXPECT_EQ(val.at(2).at(0), "foo1");
+  EXPECT_EQ(val.at(2).at(1), "bar1");
+  EXPECT_EQ(val2.at(2).at(0), "foo3");
+  EXPECT_EQ(val2.at(2).at(1), "bar3");
+
+  dynamic obj = dynamic::object("a", "b")("c", dynamic::array("d", "e", "f"));
+  EXPECT_EQ(obj.at("a"), "b");
+  dynamic obj2 = obj;
+  obj2.at("a") = dynamic::array(1, 2, 3);
+  EXPECT_EQ(obj.at("a"), "b");
+  dynamic expected = dynamic::array(1, 2, 3);
+  EXPECT_EQ(obj2.at("a"), expected);
+}
+
+TEST(Dynamic, ArrayReassignment) {
+  dynamic o = 1;
+  dynamic d1 = dynamic::array(o);
+  EXPECT_EQ(dynamic::ARRAY, d1.type());
+
+  d1 = dynamic::array(o);
+  EXPECT_EQ(dynamic::ARRAY, d1.type());
+}
+
+TEST(Dynamic, Operator) {
+  bool caught = false;
+  try {
+    dynamic d1 = dynamic::object;
+    dynamic d2 = dynamic::object;
+    auto foo = d1 < d2;
+    LOG(ERROR) << "operator < returned " << static_cast<int>(foo)
+               << " instead of throwing";
+  } catch (std::exception const&) {
+    caught = true;
+  }
+  EXPECT_TRUE(caught);
+
+  dynamic foo = "asd";
+  dynamic bar = "bar";
+  dynamic sum = foo + bar;
+  EXPECT_EQ(sum, "asdbar");
+
+  dynamic some = 12;
+  dynamic nums = 4;
+  dynamic math = some / nums;
+  EXPECT_EQ(math, 3);
+}
+
+namespace {
+
+void testOrderingOperatorsThrowForObjectTypes(
+    const dynamic& valueA, const dynamic& valueB) {
+  ASSERT_TRUE(valueA.isObject() || valueB.isObject())
+      << "This function is only intended for objects";
+
+  // The compiler will complain with "relational comparison result unused" if
+  // we don't send the result of comparison operations somewhere. So we just use
+  // an empty lambda which seems to satisfy it.
+  auto swallow = [](bool /*unused*/) {};
+
+#define FB_EXPECT_THROW(boolExpr) \
+  EXPECT_THROW(swallow(boolExpr), folly::TypeError)
+
+  FB_EXPECT_THROW(valueA < valueB);
+  FB_EXPECT_THROW(valueB < valueA);
+
+  FB_EXPECT_THROW(valueA <= valueB);
+  FB_EXPECT_THROW(valueB <= valueA);
+
+  FB_EXPECT_THROW(valueA >= valueB);
+  FB_EXPECT_THROW(valueB >= valueA);
+
+  FB_EXPECT_THROW(valueA > valueB);
+  FB_EXPECT_THROW(valueB > valueA);
+
+#undef FB_EXPECT_THROW
+}
+
+void testComparisonOperatorsForEqualDynamicValues(
+    const dynamic& valueA, const dynamic& valueB) {
+  testEqualityOperatorsForEqualValues(valueA, valueB);
+
+  if (valueA.isObject() || valueB.isObject()) {
+    // Objects don't support ordering
+    testOrderingOperatorsThrowForObjectTypes(valueA, valueB);
+  } else {
+    testOrderingOperatorsForEqualValues(valueA, valueB);
+  }
+  EXPECT_EQ(valueA.hash(), valueB.hash());
+}
+
+void testComparisonOperatorsForNotEqualDynamicValues(
+    const dynamic& smallerValue, const dynamic& largerValue) {
+  testEqualityOperatorsForNotEqualValues(smallerValue, largerValue);
+
+  if (smallerValue.isObject() || largerValue.isObject()) {
+    // Objects don't support ordering
+    testOrderingOperatorsThrowForObjectTypes(smallerValue, largerValue);
+  } else {
+    testOrderingOperatorsForNotEqualValues(smallerValue, largerValue);
+  }
+}
+
+// Calls func on all index pair permutations of 0 to (numValues - 1) where
+// smallerIndex < largerIndex.
+void executeOnOrderedIndexPairs(
+    size_t numValues,
+    std::function<void(size_t smallerIndex, size_t largerIndex)> func) {
+  // The `Idx` naming below is used to avoid local variable shadow warnings with
+  // the func parameter names, which are unnecessary but serving as
+  // documentation.
+  for (size_t smallerIdx = 0; smallerIdx < numValues; ++smallerIdx) {
+    for (size_t largerIdx = smallerIdx + 1; largerIdx < numValues;
+         ++largerIdx) {
+      func(smallerIdx, largerIdx);
+    }
+  }
+}
+
+using int64Limits = std::numeric_limits<int64_t>;
+using doubleLimits = std::numeric_limits<double>;
+
+double nextLower(double value) {
+  return std::nextafter(value, doubleLimits::lowest());
+}
+
+double nextHigher(double value) {
+  return std::nextafter(value, doubleLimits::max());
+}
+
+// Returns values of each type of dynamic, sorted in strictly increasing order
+// as defined by dynamic::operator<
+std::vector<dynamic> getUniqueOrderedValuesForAllTypes() {
+  return {
+      // NULLT
+      nullptr,
+
+      // ARRAY
+      dynamic::array(0, 1, 2),
+      dynamic::array(2, 0, 1),
+
+      // BOOL
+      false,
+      true,
+
+      // DOUBLE / INT64
+      doubleLimits::lowest(),
+      nextLower(-1.0 * std::pow(2.0, 63)),
+      int64Limits::lowest(),
+      int64Limits::lowest() + 1,
+      -1.1,
+      -1,
+      2,
+      2.2,
+      int64Limits::max() - 1,
+      int64Limits::max(),
+      doubleLimits::max(),
+      doubleLimits::infinity(),
+
+      // OBJECT - NOTE these don't actually have ordering comparison, so could
+      // be anywhere
+      dynamic::object("a", dynamic::array(1, 2, 3)),
+      dynamic::object("b", dynamic::array(1, 2, 3)),
+
+      // STRING
+      "abc",
+      "def",
+  };
+}
+
+std::vector<std::pair<dynamic, dynamic>> getNumericallyEqualPairs() {
+  auto getDoubleInt64Pair =
+      [](int64_t valueAsInt64) -> std::pair<dynamic, dynamic> {
+    return {valueAsInt64, static_cast<double>(valueAsInt64)};
+  };
+
+  return {
+      {-2.0, -2},
+      {0.0, 0},
+      {1.0, 1},
+
+      // Represents int64 min
+      getDoubleInt64Pair(folly::to_integral(std::pow(-2.0, 63))),
+
+      // Whatever double comes after int64 min
+      getDoubleInt64Pair(folly::to_integral(nextHigher(std::pow(-2.0, 63)))),
+
+      // Note int64 max can't be represented in double since it is (2^63 - 1)
+      // and at that range doubles only go in step sizes of 1024. So just go to
+      // whatever is closest.
+      getDoubleInt64Pair(folly::to_integral(nextLower(std::pow(2.0, 63)))),
+
+      {dynamic::array(1.0), dynamic::array(1)},
+      {dynamic::object("a", dynamic::array(1.0)),
+       dynamic::object("a", dynamic::array(1))},
+  };
+}
+
+} // namespace
+
+TEST(Dynamic, ComparisonOperatorsOnNotEqualValuesOfAllTypes) {
+  auto values = getUniqueOrderedValuesForAllTypes();
+
+  // Test ordering operators
+  executeOnOrderedIndexPairs(
+      values.size(), [&](size_t smallerIndex, size_t largerIndex) {
+        testComparisonOperatorsForNotEqualDynamicValues(
+            values[smallerIndex] /*smallerValue*/,
+            values[largerIndex] /*largerValue*/);
+      });
+}
+
+TEST(Dynamic, ComparisonOperatorsOnSameValuesOfSameTypes) {
+  for (const auto& value : getUniqueOrderedValuesForAllTypes()) {
+    testComparisonOperatorsForEqualDynamicValues(value, value);
+  }
+}
+
+TEST(Dynamic, ComparisonOperatorsForNumericallyEqualIntAndDoubles) {
+  for (const auto& [valueA, valueB] : getNumericallyEqualPairs()) {
+    testComparisonOperatorsForEqualDynamicValues(valueA, valueB);
+  }
+}
+
+TEST(Dynamic, HashDoesNotThrow) {
+  for (const auto& value : getUniqueOrderedValuesForAllTypes()) {
+    EXPECT_NO_THROW(std::hash<dynamic>()(value)) << value;
+  }
+}
+
+namespace {
+template <typename TExpectedHashType>
+void verifyHashMatches(double value) {
+  EXPECT_EQ(
+      folly::Hash()(static_cast<TExpectedHashType>(value)),
+      std::hash<dynamic>()(value))
+      << "value: " << value;
+}
+} // namespace
+
+TEST(Dynamic, HashOnDoublesUsesCorrectUnderlyingHasher) {
+  verifyHashMatches<double>(-1.5);
+  verifyHashMatches<int64_t>(-1.0);
+  verifyHashMatches<int64_t>(0.0);
+  verifyHashMatches<double>(0.2);
+  verifyHashMatches<int64_t>(2.0);
+}
+
+TEST(Dynamic, HashForNumericallyEqualIntAndDoubles) {
+  for (const auto& [valueA, valueB] : getNumericallyEqualPairs()) {
+    // This is just highlighting that the same hashing functions will apply
+    // to numerically equal values.
+    EXPECT_EQ(std::hash<dynamic>()(valueA), std::hash<dynamic>()(valueB))
+        << "valueA: " << valueA << ", valueB: " << valueB;
+  }
+}
+
+TEST(Dynamic, ComparisonOperatorsForNonEquivalenctCases) {
+  // Mainly highlighting some cases for which implicit conversion is not done.
+  // Within each group they are ordered per dynamic::Type enum value.
+  std::vector<std::vector<dynamic>> notEqualValueTestCases{
+      {nullptr, false, 0},
+      {true, 1},
+      {1, "1"},
+  };
+
+  for (const auto& testCase : notEqualValueTestCases) {
+    executeOnOrderedIndexPairs(
+        testCase.size(), [&](size_t smallerIndex, size_t largerIndex) {
+          testComparisonOperatorsForNotEqualDynamicValues(
+              testCase[smallerIndex] /*smallerValue*/,
+              testCase[largerIndex] /*largerValue*/);
+        });
+  }
+}
+
+TEST(Dynamic, Conversions) {
+  dynamic str = "12.0";
+  EXPECT_EQ(str.asDouble(), 12.0);
+  EXPECT_ANY_THROW(str.asInt());
+  EXPECT_ANY_THROW(str.asBool());
+
+  str = "12";
+  EXPECT_EQ(str.asInt(), 12);
+  EXPECT_EQ(str.asDouble(), 12.0);
+  str = "0";
+  EXPECT_EQ(str.asBool(), false);
+  EXPECT_EQ(str.asInt(), 0);
+  EXPECT_EQ(str.asDouble(), 0);
+  EXPECT_EQ(str.asString(), "0");
+
+  dynamic num = 12;
+  EXPECT_EQ("12", num.asString());
+  EXPECT_EQ(12.0, num.asDouble());
+}
+
+TEST(Dynamic, GetSetDefaultTest) {
+  dynamic d1 = dynamic::object("foo", "bar");
+  EXPECT_EQ(d1.getDefault("foo", "baz"), "bar");
+  EXPECT_EQ(d1.getDefault("quux", "baz"), "baz");
+
+  dynamic d2 = dynamic::object("foo", "bar");
+  EXPECT_EQ(d2.setDefault("foo", "quux"), "bar");
+  d2.setDefault("bar", dynamic::array).push_back(42);
+  EXPECT_EQ(d2["bar"][0], 42);
+
+  dynamic d3 = dynamic::object, empty = dynamic::object;
+  EXPECT_EQ(d3.getDefault("foo"), empty);
+  d3.setDefault("foo")["bar"] = "baz";
+  EXPECT_EQ(d3["foo"]["bar"], "baz");
+
+  // we do not allow getDefault/setDefault on arrays
+  dynamic d4 = dynamic::array;
+  EXPECT_ANY_THROW(d4.getDefault("foo", "bar"));
+  EXPECT_ANY_THROW(d4.setDefault("foo", "bar"));
+
+  // Using dynamic keys
+  dynamic k10{10}, k20{20}, kTrue{true};
+  dynamic d5 = dynamic::object(k10, "foo");
+  EXPECT_EQ(d5.setDefault(k10, "bar"), "foo");
+  EXPECT_EQ(d5.setDefault(k20, "bar"), "bar");
+  EXPECT_EQ(d5.setDefault(kTrue, "baz"), "baz");
+  EXPECT_EQ(d5.setDefault(StaticStrings::kA, "foo"), "foo");
+  EXPECT_EQ(d5.setDefault(StaticStrings::kB, "foo"), "foo");
+  EXPECT_EQ(d5.setDefault(StaticStrings::kFoo, "bar"), "bar");
+  EXPECT_EQ(d5.setDefault(StaticStrings::kBar, "foo"), "foo");
+}
+
+TEST(Dynamic, ObjectForwarding) {
+  // Make sure dynamic::object can be constructed the same way as any
+  // dynamic.
+  dynamic d = dynamic::object("asd", dynamic::array("foo", "bar"));
+  // clang-format off
+  dynamic d2 = dynamic::object("key2", dynamic::array("value", "words"))
+                              ("key", "value1");
+  // clang-format on
+}
+
+TEST(Dynamic, GetPtr) {
+  dynamic array = dynamic::array(1, 2, "three");
+  EXPECT_TRUE(array.get_ptr(0));
+  EXPECT_FALSE(array.get_ptr(-1));
+  EXPECT_FALSE(array.get_ptr(3));
+  EXPECT_EQ(dynamic("three"), *array.get_ptr(2));
+  const dynamic& carray = array;
+  EXPECT_EQ(dynamic("three"), *carray.get_ptr(2));
+
+  dynamic object = dynamic::object("one", 1)("two", 2);
+  EXPECT_TRUE(object.get_ptr("one"));
+  EXPECT_FALSE(object.get_ptr("three"));
+  EXPECT_EQ(dynamic(2), *object.get_ptr("two"));
+  *object.get_ptr("one") = 11;
+  EXPECT_EQ(dynamic(11), *object.get_ptr("one"));
+  const dynamic& cobject = object;
+  EXPECT_EQ(dynamic(2), *cobject.get_ptr("two"));
+}
+
+TEST(Dynamic, Assignment) {
+  const dynamic ds[] = {
+      dynamic::array(1, 2, 3),
+      dynamic::object("a", true),
+      24,
+      26.5,
+      true,
+      "hello",
+  };
+  const dynamic dd[] = {
+      dynamic::array(5, 6),
+      dynamic::object("t", "T")(1, 7),
+      9000,
+      3.14159,
+      false,
+      "world",
+  };
+  for (const auto& source : ds) {
+    for (const auto& dest : dd) {
+      dynamic tmp(dest);
+      EXPECT_EQ(tmp, dest);
+      tmp = source;
+      EXPECT_EQ(tmp, source);
+    }
+  }
+}
+
+std::string make_long_string() {
+  return std::string(100, 'a');
+}
+
+TEST(Dynamic, GetDefault) {
+  const auto s = make_long_string();
+  dynamic kDynamicKey{10};
+  dynamic ds(s);
+  dynamic tmp(s);
+  dynamic d1 = dynamic::object("key1", s);
+  dynamic d2 = dynamic::object("key2", s);
+  dynamic d3 = dynamic::object("key3", s);
+  dynamic d4 = dynamic::object("key4", s);
+  // lvalue - lvalue
+  dynamic ayy("ayy");
+  EXPECT_EQ(ds, d1.getDefault("key1", ayy));
+  EXPECT_EQ(ds, d1.getDefault("key1", ayy));
+  EXPECT_EQ(ds, d1.getDefault("not-a-key", tmp));
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kA, tmp));
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kB, tmp));
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kFoo, tmp));
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kBar, tmp));
+  EXPECT_EQ(ds, d1.getDefault(kDynamicKey, tmp));
+  EXPECT_EQ(ds, tmp);
+  // lvalue - rvalue
+  EXPECT_EQ(ds, d1.getDefault("key1", "ayy"));
+  EXPECT_EQ(ds, d1.getDefault("key1", "ayy"));
+  EXPECT_EQ(ds, d1.getDefault("not-a-key", std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kA, std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kB, std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kFoo, std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, d1.getDefault(StaticStrings::kBar, std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, d1.getDefault(kDynamicKey, std::move(tmp)));
+  EXPECT_NE(ds, tmp);
+  // rvalue - lvalue
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d1).getDefault("key1", ayy));
+  EXPECT_NE(ds, d1["key1"]);
+  EXPECT_EQ(ds, std::move(d2).getDefault("not-a-key", tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d2).getDefault(StaticStrings::kA, tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d2).getDefault(StaticStrings::kB, tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d2).getDefault(StaticStrings::kFoo, tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d2).getDefault(StaticStrings::kBar, tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d2).getDefault(kDynamicKey, tmp));
+  EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
+  EXPECT_EQ(ds, tmp);
+  // rvalue - rvalue
+  EXPECT_EQ(ds, std::move(d3).getDefault("key3", std::move(tmp)));
+  EXPECT_NE(ds, d3["key3"]);
+  EXPECT_EQ(ds, tmp);
+  EXPECT_EQ(ds, std::move(d4).getDefault("not-a-key", std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d4).getDefault(StaticStrings::kA, std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d4).getDefault(StaticStrings::kB, std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d4).getDefault(StaticStrings::kFoo, std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d4).getDefault(StaticStrings::kBar, std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+  tmp = s;
+  EXPECT_EQ(ds, std::move(d4).getDefault(kDynamicKey, std::move(tmp)));
+  EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
+  EXPECT_NE(ds, tmp);
+}
+
+TEST(Dynamic, GetString) {
+  const dynamic c(make_long_string());
+  dynamic d(make_long_string());
+  dynamic m(make_long_string());
+
+  auto s = make_long_string();
+
+  EXPECT_EQ(s, c.getString());
+  EXPECT_EQ(s, c.getString());
+
+  d.getString() += " hello";
+  EXPECT_EQ(s + " hello", d.getString());
+  EXPECT_EQ(s + " hello", d.getString());
+
+  EXPECT_EQ(s, std::move(m).getString());
+  EXPECT_EQ(s, m.getString());
+  auto moved = std::move(m).getString();
+  EXPECT_EQ(s, moved);
+  EXPECT_NE(dynamic(s), m);
+}
+
+TEST(Dynamic, GetSmallThings) {
+  const dynamic cint(5);
+  const dynamic cdouble(5.0);
+  const dynamic cbool(true);
+  dynamic dint(5);
+  dynamic ddouble(5.0);
+  dynamic dbool(true);
+  dynamic mint(5);
+  dynamic mdouble(5.0);
+  dynamic mbool(true);
+
+  EXPECT_EQ(5, cint.getInt());
+  dint.getInt() = 6;
+  EXPECT_EQ(6, dint.getInt());
+  EXPECT_EQ(5, std::move(mint).getInt());
+
+  EXPECT_EQ(5.0, cdouble.getDouble());
+  ddouble.getDouble() = 6.0;
+  EXPECT_EQ(6.0, ddouble.getDouble());
+  EXPECT_EQ(5.0, std::move(mdouble).getDouble());
+
+  EXPECT_TRUE(cbool.getBool());
+  dbool.getBool() = false;
+  EXPECT_FALSE(dbool.getBool());
+  EXPECT_TRUE(std::move(mbool).getBool());
+}
+
+TEST(Dynamic, At) {
+  const dynamic cd = dynamic::object("key1", make_long_string());
+  dynamic dd = dynamic::object("key1", make_long_string());
+  dynamic md = dynamic::object("key1", make_long_string());
+
+  dynamic ds(make_long_string());
+  EXPECT_EQ(ds, cd.at("key1"));
+  EXPECT_EQ(ds, cd.at("key1"));
+
+  dd.at("key1").getString() += " hello";
+  EXPECT_EQ(dynamic(make_long_string() + " hello"), dd.at("key1"));
+  EXPECT_EQ(dynamic(make_long_string() + " hello"), dd.at("key1"));
+
+  EXPECT_EQ(ds, std::move(md).at("key1")); // move available, but not performed
+  EXPECT_EQ(ds, md.at("key1"));
+  dynamic moved = std::move(md).at("key1"); // move performed
+  EXPECT_EQ(ds, moved);
+  EXPECT_NE(ds, md.at("key1"));
+}
+
+TEST(Dynamic, Brackets) {
+  const dynamic cd = dynamic::object("key1", make_long_string());
+  dynamic dd = dynamic::object("key1", make_long_string());
+  dynamic md = dynamic::object("key1", make_long_string());
+
+  dynamic ds(make_long_string());
+  EXPECT_EQ(ds, cd["key1"]);
+  EXPECT_EQ(ds, cd["key1"]);
+
+  dd["key1"].getString() += " hello";
+  EXPECT_EQ(dynamic(make_long_string() + " hello"), dd["key1"]);
+  EXPECT_EQ(dynamic(make_long_string() + " hello"), dd["key1"]);
+
+  EXPECT_EQ(ds, std::move(md)["key1"]); // move available, but not performed
+  EXPECT_EQ(ds, md["key1"]);
+  dynamic moved = std::move(md)["key1"]; // move performed
+  EXPECT_EQ(ds, moved);
+  EXPECT_NE(ds, md["key1"]);
+}
+
+TEST(Dynamic, PrintNull) {
+  std::stringstream ss;
+  ss << folly::dynamic(nullptr);
+  EXPECT_EQ("null", ss.str());
+}
+
+TEST(Dynamic, WriteThroughArrayIterators) {
+  dynamic const cint(0);
+  dynamic d = dynamic::array(cint, cint, cint);
+  size_t size = d.size();
+
+  for (auto& val : d) {
+    EXPECT_EQ(val, cint);
+  }
+  EXPECT_EQ(d.size(), size);
+
+  dynamic ds(make_long_string());
+  for (auto& val : d) {
+    val = ds; // assign through reference
+  }
+
+  ds = "short string";
+  dynamic ds2(make_long_string());
+
+  for (auto& val : d) {
+    EXPECT_EQ(val, ds2);
+  }
+  EXPECT_EQ(d.size(), size);
+}
+
+TEST(Dynamic, MoveOutOfArrayIterators) {
+  dynamic ds(make_long_string());
+  dynamic d = dynamic::array(ds, ds, ds);
+  size_t size = d.size();
+
+  for (auto& val : d) {
+    EXPECT_EQ(val, ds);
+  }
+  EXPECT_EQ(d.size(), size);
+
+  for (auto& val : d) {
+    dynamic waste = std::move(val); // force moving out
+    EXPECT_EQ(waste, ds);
+  }
+
+  for (auto& val : d) {
+    EXPECT_NE(val, ds);
+  }
+  EXPECT_EQ(d.size(), size);
+}
+
+TEST(Dynamic, WriteThroughObjectIterators) {
+  dynamic const cint(0);
+  dynamic d = dynamic::object("key1", cint)("key2", cint);
+  size_t size = d.size();
+
+  for (auto& val : d.items()) {
+    EXPECT_EQ(val.second, cint);
+  }
+  EXPECT_EQ(d.size(), size);
+
+  dynamic ds(make_long_string());
+  for (auto& val : d.items()) {
+    val.second = ds; // assign through reference
+  }
+
+  ds = "short string";
+  dynamic ds2(make_long_string());
+  for (auto& val : d.items()) {
+    EXPECT_EQ(val.second, ds2);
+  }
+  EXPECT_EQ(d.size(), size);
+}
+
+TEST(Dynamic, MoveOutOfObjectIterators) {
+  dynamic ds(make_long_string());
+  dynamic d = dynamic::object("key1", ds)("key2", ds);
+  size_t size = d.size();
+
+  for (auto& val : d.items()) {
+    EXPECT_EQ(val.second, ds);
+  }
+  EXPECT_EQ(d.size(), size);
+
+  for (auto& val : d.items()) {
+    dynamic waste = std::move(val.second); // force moving out
+    EXPECT_EQ(waste, ds);
+  }
+
+  for (auto& val : d.items()) {
+    EXPECT_NE(val.second, ds);
+  }
+  EXPECT_EQ(d.size(), size);
+}
+
+TEST(Dynamic, ArrayIteratorInterop) {
+  dynamic d = dynamic::array(0, 1, 2);
+  dynamic const& cdref = d;
+
+  auto it = d.begin();
+  auto cit = cdref.begin();
+
+  EXPECT_EQ(it, cit);
+  EXPECT_EQ(cit, d.begin());
+  EXPECT_EQ(it, cdref.begin());
+
+  // Erase using non-const iterator
+  it = d.erase(it);
+  cit = cdref.begin();
+  EXPECT_EQ(*it, 1);
+  EXPECT_EQ(cit, it);
+
+  // Assign from non-const to const, preserve equality
+  decltype(cit) cit2 = it;
+  EXPECT_EQ(cit, cit2);
+}
+
+TEST(Dynamic, ObjectIteratorInterop) {
+  dynamic ds = make_long_string();
+  dynamic d = dynamic::object(0, ds)(1, ds)(2, ds);
+  dynamic const& cdref = d;
+
+  auto it = d.find(0);
+  auto cit = cdref.find(0);
+  EXPECT_NE(it, cdref.items().end());
+  EXPECT_NE(cit, cdref.items().end());
+  EXPECT_EQ(it, cit);
+
+  ++cit;
+  // Erase using non-const iterator
+  auto it2 = d.erase(it);
+  EXPECT_EQ(cit, it2);
+
+  // Assign from non-const to const, preserve equality
+  decltype(cit) cit2 = it2;
+  EXPECT_EQ(cit, cit2);
+}
+
+TEST(Dynamic, MergePatchWithNonObject) {
+  dynamic target = dynamic::object("a", "b")("c", "d");
+
+  dynamic patch = dynamic::array(1, 2, 3);
+  target.merge_patch(patch);
+
+  EXPECT_TRUE(target.isArray());
+}
+
+TEST(Dynamic, MergePatchReplaceInFlatObject) {
+  dynamic target = dynamic::object("a", "b")("c", "d");
+  dynamic patch = dynamic::object("a", "z");
+
+  target.merge_patch(patch);
+
+  EXPECT_EQ("z", target["a"].getString());
+  EXPECT_EQ("d", target["c"].getString());
+}
+
+TEST(Dynamic, MergePatchAddInFlatObject) {
+  dynamic target = dynamic::object("a", "b")("c", "d");
+  dynamic patch = dynamic::object("e", "f");
+  target.merge_patch(patch);
+
+  EXPECT_EQ("b", target["a"].getString());
+  EXPECT_EQ("d", target["c"].getString());
+  EXPECT_EQ("f", target["e"].getString());
+}
+
+TEST(Dynamic, MergePatchReplaceInNestedObject) {
+  dynamic target = dynamic::object("a", dynamic::object("d", 10))("b", "c");
+  dynamic patch = dynamic::object("a", dynamic::object("d", 100));
+  target.merge_patch(patch);
+
+  EXPECT_EQ(100, target["a"]["d"].getInt());
+  EXPECT_EQ("c", target["b"].getString());
+}
+
+TEST(Dynamic, MergePatchAddInNestedObject) {
+  dynamic target = dynamic::object("a", dynamic::object("d", 10))("b", "c");
+  dynamic patch = dynamic::object("a", dynamic::object("e", "f"));
+
+  target.merge_patch(patch);
+
+  EXPECT_EQ(10, target["a"]["d"].getInt());
+  EXPECT_EQ("f", target["a"]["e"].getString());
+  EXPECT_EQ("c", target["b"].getString());
+}
+
+TEST(Dynamic, MergeNestePatch) {
+  dynamic target = dynamic::object("a", dynamic::object("d", 10))("b", "c");
+  dynamic patch = dynamic::object(
+      "a", dynamic::object("d", dynamic::array(1, 2, 3)))("b", 100);
+  target.merge_patch(patch);
+
+  EXPECT_EQ(100, target["b"].getInt());
+  {
+    auto ary = patch["a"]["d"];
+    ASSERT_TRUE(ary.isArray());
+    EXPECT_EQ(1, ary[0].getInt());
+    EXPECT_EQ(2, ary[1].getInt());
+    EXPECT_EQ(3, ary[2].getInt());
+  }
+}
+
+TEST(Dynamic, MergePatchRemoveInFlatObject) {
+  dynamic target = dynamic::object("a", "b")("c", "d");
+  dynamic patch = dynamic::object("c", nullptr);
+  target.merge_patch(patch);
+
+  EXPECT_EQ("b", target["a"].getString());
+  EXPECT_EQ(0, target.count("c"));
+}
+
+TEST(Dynamic, MergePatchRemoveInNestedObject) {
+  dynamic target =
+      dynamic::object("a", dynamic::object("d", 10)("e", "f"))("b", "c");
+  dynamic patch = dynamic::object("a", dynamic::object("e", nullptr));
+  target.merge_patch(patch);
+
+  EXPECT_EQ(10, target["a"]["d"].getInt());
+  EXPECT_EQ(0, target["a"].count("e"));
+  EXPECT_EQ("c", target["b"].getString());
+}
+
+TEST(Dynamic, MergePatchRemoveNonExistent) {
+  dynamic target = dynamic::object("a", "b")("c", "d");
+  dynamic patch = dynamic::object("e", nullptr);
+  target.merge_patch(patch);
+
+  EXPECT_EQ("b", target["a"].getString());
+  EXPECT_EQ("d", target["c"].getString());
+  EXPECT_EQ(2, target.size());
+}
+
+TEST(Dynamic, MergeDiffFlatObjects) {
+  dynamic source = dynamic::object("a", 0)("b", 1)("c", 2)("d", 3);
+  dynamic target = dynamic::object("a", 1)("b", 2)("d", 3);
+  auto patch = dynamic::merge_diff(source, target);
+
+  EXPECT_EQ(3, patch.size());
+  EXPECT_EQ(1, patch["a"].getInt());
+  EXPECT_EQ(2, patch["b"].getInt());
+  EXPECT_TRUE(patch["c"].isNull());
+
+  source.merge_patch(patch);
+  EXPECT_EQ(source, target);
+}
+
+TEST(Dynamic, MergeDiffNestedObjects) {
+  // clang-format off
+  dynamic source = dynamic::object
+    ("a", dynamic::object("b", 1)("c", 2)("d", 3))
+    ("e", dynamic::array(1, 2, 3))
+    ("f", dynamic::array(4, 5, 6));
+  dynamic target = dynamic::object
+    ("a", dynamic::object("b", 2)("d", 3))
+    ("e", dynamic::array(2, 3, 4))
+    ("f", dynamic::array(4, 5, 6));
+  // clang-format on
+
+  auto patch = dynamic::merge_diff(source, target);
+
+  EXPECT_EQ(2, patch.size());
+  EXPECT_EQ(2, patch["a"].size());
+
+  EXPECT_EQ(2, patch["a"]["b"].getInt());
+  EXPECT_TRUE(patch["a"]["c"].isNull());
+
+  EXPECT_TRUE(patch["e"].isArray());
+  EXPECT_EQ(3, patch["e"].size());
+  EXPECT_EQ(2, patch["e"][0].getInt());
+  EXPECT_EQ(3, patch["e"][1].getInt());
+  EXPECT_EQ(4, patch["e"][2].getInt());
+
+  source.merge_patch(patch);
+  EXPECT_EQ(source, target);
+}
+
+using folly::json_pointer;
+
+TEST(Dynamic, JSONPointer) {
+  using err_code = folly::dynamic::json_pointer_resolution_error_code;
+
+  dynamic target = dynamic::object;
+  dynamic ary = dynamic::array("bar", "baz", dynamic::array("bletch", "xyzzy"));
+  target["foo"] = ary;
+  target[""] = 0;
+  target["a/b"] = 1;
+  target["c%d"] = 2;
+  target["e^f"] = 3;
+  target["g|h"] = 4;
+  target["i\\j"] = 5;
+  target["k\"l"] = 6;
+  target[" "] = 7;
+  target["m~n"] = 8;
+  target["xyz"] = dynamic::object;
+  target["xyz"][""] = dynamic::object("nested", "abc");
+  target["xyz"]["def"] = dynamic::array(1, 2, 3);
+  target["long_array"] = dynamic::array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+  target["-"] = dynamic::object("x", "y");
+
+  EXPECT_EQ(target, *target.get_ptr(json_pointer::parse("")));
+  EXPECT_EQ(ary, *(target.get_ptr(json_pointer::parse("/foo"))));
+  EXPECT_EQ("bar", target.get_ptr(json_pointer::parse("/foo/0"))->getString());
+  EXPECT_EQ(0, target.get_ptr(json_pointer::parse("/"))->getInt());
+  EXPECT_EQ(1, target.get_ptr(json_pointer::parse("/a~1b"))->getInt());
+  EXPECT_EQ(2, target.get_ptr(json_pointer::parse("/c%d"))->getInt());
+  EXPECT_EQ(3, target.get_ptr(json_pointer::parse("/e^f"))->getInt());
+  EXPECT_EQ(4, target.get_ptr(json_pointer::parse("/g|h"))->getInt());
+  EXPECT_EQ(5, target.get_ptr(json_pointer::parse("/i\\j"))->getInt());
+  EXPECT_EQ(6, target.get_ptr(json_pointer::parse("/k\"l"))->getInt());
+  EXPECT_EQ(7, target.get_ptr(json_pointer::parse("/ "))->getInt());
+  EXPECT_EQ(8, target.get_ptr(json_pointer::parse("/m~0n"))->getInt());
+  // empty key in path
+  EXPECT_EQ(
+      "abc", target.get_ptr(json_pointer::parse("/xyz//nested"))->getString());
+  EXPECT_EQ(3, target.get_ptr(json_pointer::parse("/xyz/def/2"))->getInt());
+  EXPECT_EQ("baz", ary.get_ptr(json_pointer::parse("/1"))->getString());
+  EXPECT_EQ("bletch", ary.get_ptr(json_pointer::parse("/2/0"))->getString());
+  // double-digit index
+  EXPECT_EQ(
+      12, target.get_ptr(json_pointer::parse("/long_array/11"))->getInt());
+  // allow '-' to index in objects
+  EXPECT_EQ("y", target.get_ptr(json_pointer::parse("/-/x"))->getString());
+
+  // validate parent pointer functionality
+
+  {
+    auto const resolved_value =
+        target.try_get_ptr(json_pointer::parse("")).value();
+    EXPECT_EQ(nullptr, resolved_value.parent);
+  }
+
+  {
+    auto parent_json_ptr = json_pointer::parse("/xyz");
+    auto json_ptr = json_pointer::parse("/xyz/def");
+
+    auto const parent = target.get_ptr(parent_json_ptr);
+    auto const resolved_value = target.try_get_ptr(json_ptr);
+
+    EXPECT_EQ(parent, resolved_value.value().parent);
+    EXPECT_TRUE(parent->isObject());
+    EXPECT_EQ("def", resolved_value.value().parent_key);
+  }
+
+  {
+    auto parent_json_ptr = json_pointer::parse("/foo");
+    auto json_ptr = json_pointer::parse("/foo/1");
+
+    auto const parent = target.get_ptr(parent_json_ptr);
+    auto const resolved_value = target.try_get_ptr(json_ptr);
+
+    EXPECT_EQ(parent, resolved_value.value().parent);
+    EXPECT_TRUE(parent->isArray());
+    EXPECT_EQ(1, resolved_value.value().parent_index);
+  }
+
+  //
+  // invalid pointer resolution cases
+  //
+
+  // invalid index formatting when accessing array
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foo/01")).error();
+    EXPECT_EQ(err_code::index_has_leading_zero, err.error_code);
+    EXPECT_EQ(1, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("/foo")), err.context);
+    EXPECT_THROW(
+        target.get_ptr(json_pointer::parse("/foo/01")), std::invalid_argument);
+  }
+
+  // non-existent keys/indexes
+  {
+    auto err = ary.try_get_ptr(json_pointer::parse("/3")).error();
+    EXPECT_EQ(err_code::index_out_of_bounds, err.error_code);
+    EXPECT_EQ(0, err.index);
+    EXPECT_EQ(ary.get_ptr(json_pointer::parse("")), err.context);
+    EXPECT_EQ(nullptr, ary.get_ptr(json_pointer::parse("/3")));
+  }
+
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/unknown_key")).error();
+    EXPECT_EQ(err_code::key_not_found, err.error_code);
+    EXPECT_EQ(0, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("")), err.context);
+    EXPECT_EQ(nullptr, target.get_ptr(json_pointer::parse("/unknown_key")));
+  }
+
+  // fail to resolve index inside string
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foo/0/0")).error();
+    EXPECT_EQ(err_code::element_not_object_or_array, err.error_code);
+    EXPECT_EQ(2, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("/foo/0")), err.context);
+    EXPECT_THROW(
+        target.get_ptr(json_pointer::parse("/foo/0/0")), folly::TypeError);
+  }
+
+  // intermediate key not found
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foox/test")).error();
+    EXPECT_EQ(err_code::key_not_found, err.error_code);
+    EXPECT_EQ(0, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("")), err.context);
+    EXPECT_EQ(nullptr, target.get_ptr(json_pointer::parse("/foox/test")));
+  }
+
+  // Intermediate key is '-' in _array_
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foo/-/key")).error();
+    EXPECT_EQ(err_code::json_pointer_out_of_bounds, err.error_code);
+    EXPECT_EQ(2, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("/foo")), err.context);
+    EXPECT_EQ(nullptr, target.get_ptr(json_pointer::parse("/foo/-/key")));
+  }
+
+  // invalid path in object (non-numeric index in array)
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foo/2/bar")).error();
+    EXPECT_EQ(err_code::index_not_numeric, err.error_code);
+    EXPECT_EQ(2, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("/foo/2")), err.context);
+    EXPECT_THROW(
+        target.get_ptr(json_pointer::parse("/foo/2/bar")),
+        std::invalid_argument);
+  }
+
+  // Allow "-" index in the array
+  {
+    auto err = target.try_get_ptr(json_pointer::parse("/foo/-")).error();
+    EXPECT_EQ(err_code::append_requested, err.error_code);
+    EXPECT_EQ(1, err.index);
+    EXPECT_EQ(target.get_ptr(json_pointer::parse("/foo")), err.context);
+    EXPECT_EQ(nullptr, target.get_ptr(json_pointer::parse("/foo/-")));
+  }
+}
+
+TEST(Dynamic, Math) {
+  // tests int-int, int-double, double-int, and double-double math operations
+  std::vector<dynamic> values = {2, 5.0};
+
+  // addition
+  for (auto value1 : values) {
+    for (auto value2 : values) {
+      auto testValue = value1;
+      testValue += value2;
+      EXPECT_NEAR(
+          value1.asDouble() + value2.asDouble(), testValue.asDouble(), 0.0001);
+    }
+  }
+
+  // subtraction
+  for (auto value1 : values) {
+    for (auto value2 : values) {
+      auto testValue = value1;
+      testValue -= value2;
+      EXPECT_NEAR(
+          value1.asDouble() - value2.asDouble(), testValue.asDouble(), 0.0001);
+    }
+  }
+
+  // multiplication
+  for (auto value1 : values) {
+    for (auto value2 : values) {
+      auto testValue = value1;
+      testValue *= value2;
+      EXPECT_NEAR(
+          value1.asDouble() * value2.asDouble(), testValue.asDouble(), 0.0001);
+    }
+  }
+
+  // division
+  for (auto value1 : values) {
+    for (auto value2 : values) {
+      auto testValue = value1;
+      testValue /= value2;
+      EXPECT_NEAR(
+          value1.asDouble() / value2.asDouble(), testValue.asDouble(), 0.0001);
+    }
+  }
+}
+
+dynamic buildNestedKeys(size_t depth) {
+  if (depth == 0) {
+    return dynamic(0);
+  }
+  return dynamic::object(buildNestedKeys(depth - 1), 0);
+}
+
+dynamic buildNestedValues(size_t depth) {
+  if (depth == 0) {
+    return dynamic(0);
+  }
+  return dynamic::object(0, buildNestedValues(depth - 1));
+}
+
+TEST(Dynamic, EqualNestedKeys) {
+  // This tests for exponential behavior in the depth of the keys.
+  // If it is exponential this test won't finish.
+  size_t const kDepth = 100;
+  dynamic obj1 = buildNestedKeys(kDepth);
+  dynamic obj2 = obj1;
+  EXPECT_EQ(obj1, obj2);
+}
+
+TEST(Dynamic, EqualNestedValues) {
+  // This tests for exponential behavior in the depth of the values.
+  // If it is exponential this test won't finish.
+  size_t const kDepth = 100;
+  dynamic obj1 = buildNestedValues(kDepth);
+  dynamic obj2 = obj1;
+  EXPECT_EQ(obj1, obj2);
+}
+
+} // namespace test
+} // namespace folly