Extracted VariantData and CollectionData classes

test/JsonArray/equals.cpp

@@ -22,7 +22,25 @@ TEST_CASE("JsonArray::operator==()") {
     REQUIRE_FALSE(array1c == array2c);
   }
 
-  SECTION("should return false when arrays differ") {
+  SECTION("should return false when LHS has more elements") {
+    array1.add(1);
+    array1.add(2);
+    array2.add(1);
+
+    REQUIRE_FALSE(array1 == array2);
+    REQUIRE_FALSE(array1c == array2c);
+  }
+
+  SECTION("should return false when RKS has more elements") {
+    array1.add(1);
+    array2.add(1);
+    array2.add(2);
+
+    REQUIRE_FALSE(array1 == array2);
+    REQUIRE_FALSE(array1c == array2c);
+  }
+
+  SECTION("should return true when arrays equal") {
     array1.add("coucou");
     array2.add("coucou");
 

test/JsonObject/equals.cpp

@@ -22,7 +22,25 @@ TEST_CASE("JsonObject::operator==()") {
     REQUIRE_FALSE(obj1c == obj2c);
   }
 
-  SECTION("should return false when objs differ") {
+  SECTION("should return false when LHS has more elements") {
+    obj1["hello"] = "coucou";
+    obj1["world"] = 666;
+    obj2["hello"] = "coucou";
+
+    REQUIRE_FALSE(obj1 == obj2);
+    REQUIRE_FALSE(obj1c == obj2c);
+  }
+
+  SECTION("should return false when RKS has more elements") {
+    obj1["hello"] = "coucou";
+    obj2["hello"] = "coucou";
+    obj2["world"] = 666;
+
+    REQUIRE_FALSE(obj1 == obj2);
+    REQUIRE_FALSE(obj1c == obj2c);
+  }
+
+  SECTION("should return true when objs equal") {
     obj1["hello"] = "world";
     obj1["anwser"] = 42;
     // insert in different order

test/MemoryPool/StringBuilder.cpp

@@ -12,30 +12,30 @@ static char buffer[4096];
 
 TEST_CASE("StringBuilder") {
   SECTION("Works when buffer is big enough") {
-    MemoryPool memoryPool(buffer, addPadding(JSON_STRING_SIZE(6)));
+    MemoryPool pool(buffer, addPadding(JSON_STRING_SIZE(6)));
 
-    StringBuilder str(&memoryPool);
+    StringBuilder str(&pool);
     str.append("hello");
 
-    REQUIRE(str.complete().equals("hello"));
+    REQUIRE(str.complete() == std::string("hello"));
   }
 
   SECTION("Returns null when too small") {
-    MemoryPool memoryPool(buffer, sizeof(void*));
+    MemoryPool pool(buffer, sizeof(void*));
 
-    StringBuilder str(&memoryPool);
+    StringBuilder str(&pool);
     str.append("hello world!");
 
-    REQUIRE(str.complete().isNull());
+    REQUIRE(str.complete() == 0);
   }
 
   SECTION("Increases size of memory pool") {
-    MemoryPool memoryPool(buffer, addPadding(JSON_STRING_SIZE(6)));
+    MemoryPool pool(buffer, addPadding(JSON_STRING_SIZE(6)));
 
-    StringBuilder str(&memoryPool);
+    StringBuilder str(&pool);
     str.append('h');
     str.complete();
 
-    REQUIRE(JSON_STRING_SIZE(2) == memoryPool.size());
+    REQUIRE(JSON_STRING_SIZE(2) == pool.size());
   }
 }

test/MemoryPool/clear.cpp

@@ -11,21 +11,21 @@ static const size_t poolCapacity = 512;
 
 TEST_CASE("MemoryPool::clear()") {
   char buffer[poolCapacity];
-  MemoryPool memoryPool(buffer, sizeof(buffer));
+  MemoryPool pool(buffer, sizeof(buffer));
 
   SECTION("Discards allocated variants") {
-    memoryPool.allocVariant();
+    pool.allocVariant();
 
-    memoryPool.clear();
-    REQUIRE(memoryPool.size() == 0);
+    pool.clear();
+    REQUIRE(pool.size() == 0);
   }
 
   SECTION("Discards allocated strings") {
-    memoryPool.allocFrozenString(10);
-    REQUIRE(memoryPool.size() > 0);
+    pool.allocFrozenString(10);
+    REQUIRE(pool.size() > 0);
 
-    memoryPool.clear();
+    pool.clear();
 
-    REQUIRE(memoryPool.size() == 0);
+    REQUIRE(pool.size() == 0);
   }
 }

test/MemoryPool/size.cpp

@@ -11,48 +11,48 @@ char buffer[4096];
 
 TEST_CASE("MemoryPool::capacity()") {
   const size_t capacity = 64;
-  MemoryPool memoryPool(buffer, capacity);
-  REQUIRE(capacity == memoryPool.capacity());
+  MemoryPool pool(buffer, capacity);
+  REQUIRE(capacity == pool.capacity());
 }
 
 TEST_CASE("MemoryPool::size()") {
-  MemoryPool memoryPool(buffer, sizeof(buffer));
+  MemoryPool pool(buffer, sizeof(buffer));
 
   SECTION("Initial size is 0") {
-    REQUIRE(0 == memoryPool.size());
+    REQUIRE(0 == pool.size());
   }
 
   SECTION("size() == capacity() after allocExpandableString()") {
-    memoryPool.allocExpandableString();
-    REQUIRE(memoryPool.size() == memoryPool.capacity());
+    pool.allocExpandableString();
+    REQUIRE(pool.size() == pool.capacity());
   }
 
   SECTION("Decreases after freezeString()") {
-    StringSlot a = memoryPool.allocExpandableString();
-    memoryPool.freezeString(a, 1);
-    REQUIRE(memoryPool.size() == JSON_STRING_SIZE(1));
+    StringSlot a = pool.allocExpandableString();
+    pool.freezeString(a, 1);
+    REQUIRE(pool.size() == JSON_STRING_SIZE(1));
 
-    StringSlot b = memoryPool.allocExpandableString();
-    memoryPool.freezeString(b, 1);
-    REQUIRE(memoryPool.size() == 2 * JSON_STRING_SIZE(1));
+    StringSlot b = pool.allocExpandableString();
+    pool.freezeString(b, 1);
+    REQUIRE(pool.size() == 2 * JSON_STRING_SIZE(1));
   }
 
   SECTION("Increases after allocFrozenString()") {
-    memoryPool.allocFrozenString(0);
-    REQUIRE(memoryPool.size() == JSON_STRING_SIZE(0));
+    pool.allocFrozenString(0);
+    REQUIRE(pool.size() == JSON_STRING_SIZE(0));
 
-    memoryPool.allocFrozenString(0);
-    REQUIRE(memoryPool.size() == 2 * JSON_STRING_SIZE(0));
+    pool.allocFrozenString(0);
+    REQUIRE(pool.size() == 2 * JSON_STRING_SIZE(0));
   }
 
   SECTION("Doesn't grow when memory pool is full") {
     const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot);
 
-    for (size_t i = 0; i < variantCount; i++) memoryPool.allocVariant();
-    size_t size = memoryPool.size();
+    for (size_t i = 0; i < variantCount; i++) pool.allocVariant();
+    size_t size = pool.size();
 
-    memoryPool.allocVariant();
+    pool.allocVariant();
 
-    REQUIRE(size == memoryPool.size());
+    REQUIRE(size == pool.size());
   }
 }