add missing lib

lib/ArduinoJson/test/JsonBuffer/CMakeLists.txt

@@ -0,0 +1,14 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
+# MIT License
+
+add_executable(JsonBufferTests
+	nested.cpp
+	nestingLimit.cpp
+	parse.cpp
+	parseArray.cpp
+	parseObject.cpp
+)
+
+target_link_libraries(JsonBufferTests catch)
+add_test(JsonBuffer JsonBufferTests)

lib/ArduinoJson/test/JsonBuffer/nested.cpp

@@ -0,0 +1,63 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonBuffer nested objects") {
+  SECTION("ArrayNestedInObject") {
+    DynamicJsonBuffer jsonBuffer;
+    char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } ";
+
+    JsonObject &object = jsonBuffer.parseObject(jsonString);
+    JsonArray &array1 = object["ab"];
+    const JsonArray &array2 = object["cd"];
+    JsonArray &array3 = object["ef"];
+
+    REQUIRE(true == object.success());
+
+    REQUIRE(true == array1.success());
+    REQUIRE(true == array2.success());
+    REQUIRE(false == array3.success());
+
+    REQUIRE(2 == array1.size());
+    REQUIRE(2 == array2.size());
+    REQUIRE(0 == array3.size());
+
+    REQUIRE(1 == array1[0].as<int>());
+    REQUIRE(2 == array1[1].as<int>());
+
+    REQUIRE(3 == array2[0].as<int>());
+    REQUIRE(4 == array2[1].as<int>());
+
+    REQUIRE(0 == array3[0].as<int>());
+  }
+
+  SECTION("ObjectNestedInArray") {
+    DynamicJsonBuffer jsonBuffer;
+    char jsonString[] =
+        " [ { \"a\" : 1 , \"b\" : 2 } , { \"c\" : 3 , \"d\" : 4 } ] ";
+
+    JsonArray &array = jsonBuffer.parseArray(jsonString);
+    JsonObject &object1 = array[0];
+    const JsonObject &object2 = array[1];
+    JsonObject &object3 = array[2];
+
+    REQUIRE(true == array.success());
+
+    REQUIRE(true == object1.success());
+    REQUIRE(true == object2.success());
+    REQUIRE(false == object3.success());
+
+    REQUIRE(2 == object1.size());
+    REQUIRE(2 == object2.size());
+    REQUIRE(0 == object3.size());
+
+    REQUIRE(1 == object1["a"].as<int>());
+    REQUIRE(2 == object1["b"].as<int>());
+    REQUIRE(3 == object2["c"].as<int>());
+    REQUIRE(4 == object2["d"].as<int>());
+    REQUIRE(0 == object3["e"].as<int>());
+  }
+}

lib/ArduinoJson/test/JsonBuffer/nestingLimit.cpp

@@ -0,0 +1,48 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+bool tryParseArray(const char *json, uint8_t nestingLimit) {
+  DynamicJsonBuffer buffer;
+  return buffer.parseArray(json, nestingLimit).success();
+}
+
+bool tryParseObject(const char *json, uint8_t nestingLimit) {
+  DynamicJsonBuffer buffer;
+  return buffer.parseObject(json, nestingLimit).success();
+}
+
+TEST_CASE("JsonParser nestingLimit") {
+  SECTION("ParseArrayWithNestingLimit0") {
+    REQUIRE(true == tryParseArray("[]", 0));
+    REQUIRE(false == tryParseArray("[[]]", 0));
+  }
+
+  SECTION("ParseArrayWithNestingLimit1") {
+    REQUIRE(true == tryParseArray("[[]]", 1));
+    REQUIRE(false == tryParseArray("[[[]]]", 1));
+  }
+
+  SECTION("ParseArrayWithNestingLimit2") {
+    REQUIRE(true == tryParseArray("[[[]]]", 2));
+    REQUIRE(false == tryParseArray("[[[[]]]]", 2));
+  }
+
+  SECTION("ParseObjectWithNestingLimit0") {
+    REQUIRE(true == tryParseObject("{}", 0));
+    REQUIRE(false == tryParseObject("{\"key\":{}}", 0));
+  }
+
+  SECTION("ParseObjectWithNestingLimit1") {
+    REQUIRE(true == tryParseObject("{\"key\":{}}", 1));
+    REQUIRE(false == tryParseObject("{\"key\":{\"key\":{}}}", 1));
+  }
+
+  SECTION("ParseObjectWithNestingLimit2") {
+    REQUIRE(true == tryParseObject("{\"key\":{\"key\":{}}}", 2));
+    REQUIRE(false == tryParseObject("{\"key\":{\"key\":{\"key\":{}}}}", 2));
+  }
+}

lib/ArduinoJson/test/JsonBuffer/parse.cpp

@@ -0,0 +1,80 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace Catch::Matchers;
+
+TEST_CASE("JsonBuffer::parse()") {
+  DynamicJsonBuffer jb;
+
+  SECTION("EmptyObject") {
+    JsonVariant variant = jb.parse("{}");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<JsonObject>());
+  }
+
+  SECTION("EmptyArray") {
+    JsonVariant variant = jb.parse("[]");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<JsonArray>());
+  }
+
+  SECTION("Integer") {
+    JsonVariant variant = jb.parse("-42");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<int>());
+    REQUIRE_FALSE(variant.is<bool>());
+    REQUIRE(variant == -42);
+  }
+
+  SECTION("Double") {
+    JsonVariant variant = jb.parse("-1.23e+4");
+    REQUIRE(variant.success());
+    REQUIRE_FALSE(variant.is<int>());
+    REQUIRE(variant.is<double>());
+    REQUIRE(variant.as<double>() == Approx(-1.23e+4));
+  }
+
+  SECTION("Double quoted string") {
+    JsonVariant variant = jb.parse("\"hello world\"");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<char*>());
+    REQUIRE_THAT(variant.as<char*>(), Equals("hello world"));
+  }
+
+  SECTION("Single quoted string") {
+    JsonVariant variant = jb.parse("\'hello world\'");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<char*>());
+    REQUIRE_THAT(variant.as<char*>(), Equals("hello world"));
+  }
+
+  SECTION("True") {
+    JsonVariant variant = jb.parse("true");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<bool>());
+    REQUIRE(variant == true);
+  }
+
+  SECTION("False") {
+    JsonVariant variant = jb.parse("false");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<bool>());
+    REQUIRE(variant == false);
+  }
+
+  SECTION("OpenBrace") {
+    JsonVariant variant = jb.parse("{");
+    REQUIRE_FALSE(variant.success());
+  }
+
+  SECTION("Incomplete string") {
+    JsonVariant variant = jb.parse("\"hello");
+    REQUIRE(variant.success());
+    REQUIRE(variant.is<char*>());
+    REQUIRE_THAT(variant.as<char*>(), Equals("hello"));
+  }
+}

lib/ArduinoJson/test/JsonBuffer/parseArray.cpp

@@ -0,0 +1,318 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonBuffer::parseArray()") {
+  DynamicJsonBuffer jb;
+
+  SECTION("EmptyArray") {
+    JsonArray& arr = jb.parseArray("[]");
+
+    REQUIRE(arr.success());
+    REQUIRE(0 == arr.size());
+  }
+
+  SECTION("MissingOpeningBracket") {
+    JsonArray& arr = jb.parseArray("]");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("ArrayWithNoEnd") {
+    JsonArray& arr = jb.parseArray("[");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("EmptyArrayWithLeadingSpaces") {
+    JsonArray& arr = jb.parseArray("  []");
+
+    REQUIRE(arr.success());
+    REQUIRE(0 == arr.size());
+  }
+
+  SECTION("Garbage") {
+    JsonArray& arr = jb.parseArray("%*$£¤");
+
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("OneInteger") {
+    JsonArray& arr = jb.parseArray("[42]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == 42);
+  }
+
+  SECTION("OneIntegerWithSpacesBefore") {
+    JsonArray& arr = jb.parseArray("[ \t\r\n42]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == 42);
+  }
+
+  SECTION("OneIntegerWithSpaceAfter") {
+    JsonArray& arr = jb.parseArray("[42 \t\r\n]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == 42);
+  }
+
+  SECTION("TwoIntegers") {
+    JsonArray& arr = jb.parseArray("[42,84]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == 42);
+    REQUIRE(arr[1] == 84);
+  }
+
+  SECTION("TwoDoubles") {
+    JsonArray& arr = jb.parseArray("[4.2,1e2]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == 4.2);
+    REQUIRE(arr[1] == 1e2);
+  }
+
+  SECTION("UnsignedLong") {
+    JsonArray& arr = jb.parseArray("[4294967295]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == 4294967295UL);
+  }
+
+  SECTION("TwoBooleans") {
+    JsonArray& arr = jb.parseArray("[true,false]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == true);
+    REQUIRE(arr[1] == false);
+  }
+
+  SECTION("TwoNulls") {
+    JsonArray& arr = jb.parseArray("[null,null]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0].as<char*>() == 0);
+    REQUIRE(arr[1].as<char*>() == 0);
+  }
+
+  SECTION("TwoStringsDoubleQuotes") {
+    JsonArray& arr = jb.parseArray("[ \"hello\" , \"world\" ]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("TwoStringsSingleQuotes") {
+    JsonArray& arr = jb.parseArray("[ 'hello' , 'world' ]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("TwoStringsNoQuotes") {
+    JsonArray& arr = jb.parseArray("[ hello , world ]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("EmptyStringsDoubleQuotes") {
+    JsonArray& arr = jb.parseArray("[\"\",\"\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "");
+    REQUIRE(arr[1] == "");
+  }
+
+  SECTION("EmptyStringSingleQuotes") {
+    JsonArray& arr = jb.parseArray("[\'\',\'\']");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "");
+    REQUIRE(arr[1] == "");
+  }
+
+  SECTION("EmptyStringNoQuotes") {
+    JsonArray& arr = jb.parseArray("[,]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "");
+    REQUIRE(arr[1] == "");
+  }
+
+  SECTION("ClosingDoubleQuoteMissing") {
+    JsonArray& arr = jb.parseArray("[\"]");
+
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("ClosingSignleQuoteMissing") {
+    JsonArray& arr = jb.parseArray("[\']");
+
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("StringWithEscapedChars") {
+    JsonArray& arr = jb.parseArray("[\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "1\"2\\3/4\b5\f6\n7\r8\t9");
+  }
+
+  SECTION("StringWithUnterminatedEscapeSequence") {
+    JsonArray& arr = jb.parseArray("\"\\\0\"", 4);
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("CCommentBeforeOpeningBracket") {
+    JsonArray& arr = jb.parseArray("/*COMMENT*/  [\"hello\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CCommentAfterOpeningBracket") {
+    JsonArray& arr = jb.parseArray("[/*COMMENT*/ \"hello\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CCommentBeforeClosingBracket") {
+    JsonArray& arr = jb.parseArray("[\"hello\"/*COMMENT*/]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CCommentAfterClosingBracket") {
+    JsonArray& arr = jb.parseArray("[\"hello\"]/*COMMENT*/");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CCommentBeforeComma") {
+    JsonArray& arr = jb.parseArray("[\"hello\"/*COMMENT*/,\"world\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("CCommentAfterComma") {
+    JsonArray& arr = jb.parseArray("[\"hello\",/*COMMENT*/ \"world\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("CppCommentBeforeOpeningBracket") {
+    JsonArray& arr = jb.parseArray("//COMMENT\n\t[\"hello\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CppCommentAfterOpeningBracket") {
+    JsonArray& arr = jb.parseArray("[//COMMENT\n\"hello\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CppCommentBeforeClosingBracket") {
+    JsonArray& arr = jb.parseArray("[\"hello\"//COMMENT\r\n]");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CppCommentAfterClosingBracket") {
+    JsonArray& arr = jb.parseArray("[\"hello\"]//COMMENT\n");
+
+    REQUIRE(arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(arr[0] == "hello");
+  }
+
+  SECTION("CppCommentBeforeComma") {
+    JsonArray& arr = jb.parseArray("[\"hello\"//COMMENT\n,\"world\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("CppCommentAfterComma") {
+    JsonArray& arr = jb.parseArray("[\"hello\",//COMMENT\n\"world\"]");
+
+    REQUIRE(arr.success());
+    REQUIRE(2 == arr.size());
+    REQUIRE(arr[0] == "hello");
+    REQUIRE(arr[1] == "world");
+  }
+
+  SECTION("InvalidCppComment") {
+    JsonArray& arr = jb.parseArray("[/COMMENT\n]");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("InvalidComment") {
+    JsonArray& arr = jb.parseArray("[/*/\n]");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("UnfinishedCComment") {
+    JsonArray& arr = jb.parseArray("[/*COMMENT]");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("EndsInCppComment") {
+    JsonArray& arr = jb.parseArray("[//COMMENT");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("AfterClosingStar") {
+    JsonArray& arr = jb.parseArray("[/*COMMENT*");
+    REQUIRE_FALSE(arr.success());
+  }
+
+  SECTION("DeeplyNested") {
+    JsonArray& arr =
+        jb.parseArray("[[[[[[[[[[[[[[[[[[[\"Not too deep\"]]]]]]]]]]]]]]]]]]]");
+    REQUIRE(arr.success());
+  }
+}

lib/ArduinoJson/test/JsonBuffer/parseObject.cpp

@@ -0,0 +1,170 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonBuffer::parseObject()") {
+  DynamicJsonBuffer jb;
+
+  SECTION("An empty object") {
+    JsonObject& obj = jb.parseObject("{}");
+    REQUIRE(obj.success());
+    REQUIRE(obj.size() == 0);
+  }
+
+  SECTION("Quotes") {
+    SECTION("Double quotes") {
+      JsonObject& obj = jb.parseObject("{\"key\":\"value\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("Single quotes") {
+      JsonObject& obj = jb.parseObject("{'key':'value'}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("No quotes") {
+      JsonObject& obj = jb.parseObject("{key:value}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("No quotes, allow underscore in key") {
+      JsonObject& obj = jb.parseObject("{_k_e_y_:42}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["_k_e_y_"] == 42);
+    }
+  }
+
+  SECTION("Spaces") {
+    SECTION("Before the key") {
+      JsonObject& obj = jb.parseObject("{ \"key\":\"value\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("After the key") {
+      JsonObject& obj = jb.parseObject("{\"key\" :\"value\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("Before the value") {
+      JsonObject& obj = jb.parseObject("{\"key\": \"value\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("After the value") {
+      JsonObject& obj = jb.parseObject("{\"key\":\"value\" }");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 1);
+      REQUIRE(obj["key"] == "value");
+    }
+
+    SECTION("Before the colon") {
+      JsonObject& obj =
+          jb.parseObject("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == "value1");
+      REQUIRE(obj["key2"] == "value2");
+    }
+
+    SECTION("After the colon") {
+      JsonObject& obj =
+          jb.parseObject("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == "value1");
+      REQUIRE(obj["key2"] == "value2");
+    }
+  }
+
+  SECTION("Values types") {
+    SECTION("String") {
+      JsonObject& obj =
+          jb.parseObject("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == "value1");
+      REQUIRE(obj["key2"] == "value2");
+    }
+
+    SECTION("Integer") {
+      JsonObject& obj = jb.parseObject("{\"key1\":42,\"key2\":-42}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == 42);
+      REQUIRE(obj["key2"] == -42);
+    }
+
+    SECTION("Double") {
+      JsonObject& obj = jb.parseObject("{\"key1\":12.345,\"key2\":-7E89}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == 12.345);
+      REQUIRE(obj["key2"] == -7E89);
+    }
+
+    SECTION("Booleans") {
+      JsonObject& obj = jb.parseObject("{\"key1\":true,\"key2\":false}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"] == true);
+      REQUIRE(obj["key2"] == false);
+    }
+
+    SECTION("Null") {
+      JsonObject& obj = jb.parseObject("{\"key1\":null,\"key2\":null}");
+      REQUIRE(obj.success());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"].as<char*>() == 0);
+      REQUIRE(obj["key2"].as<char*>() == 0);
+    }
+  }
+
+  SECTION("Misc") {
+    SECTION("The opening brace is missing") {
+      JsonObject& obj = jb.parseObject("}");
+      REQUIRE_FALSE(obj.success());
+    }
+
+    SECTION("The closing brace is missing") {
+      JsonObject& obj = jb.parseObject("{");
+      REQUIRE_FALSE(obj.success());
+    }
+
+    SECTION("A quoted key without value") {
+      JsonObject& obj = jb.parseObject("{\"key\"}");
+      REQUIRE_FALSE(obj.success());
+    }
+
+    SECTION("A non-quoted key without value") {
+      JsonObject& obj = jb.parseObject("{key}");
+      REQUIRE_FALSE(obj.success());
+    }
+
+    SECTION("A dangling comma") {
+      JsonObject& obj = jb.parseObject("{\"key1\":\"value1\",}");
+      REQUIRE_FALSE(obj.success());
+      REQUIRE(obj.size() == 0);
+    }
+
+    SECTION("null as a key") {
+      JsonObject& obj = jb.parseObject("null:\"value\"}");
+      REQUIRE_FALSE(obj.success());
+    }
+  }
+}