Merged MsgPackError and JsonError into DeserializationError.

Return NotSupported if the JSON input contains "\u".

test/JsonDeserializer/CMakeLists.txt

@@ -8,7 +8,7 @@ add_executable(JsonDeserializerTests
 	deserializeJsonObject.cpp
 	deserializeJsonObjectStatic.cpp
 	deserializeJsonValue.cpp
-	JsonError.cpp
+	DeserializationError.cpp
 	nestingLimit.cpp
 	std_istream.cpp
 	std_string.cpp

test/JsonDeserializer/DeserializationError.cpp

@@ -5,27 +5,28 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
-void testStringification(JsonError error, std::string expected) {
+void testStringification(DeserializationError error, std::string expected) {
   REQUIRE(error.c_str() == expected);
 }
 
-void testBoolification(JsonError error, bool expected) {
+void testBoolification(DeserializationError error, bool expected) {
   CHECK(error == expected);
 }
 
 #define TEST_STRINGIFICATION(symbol) \
-  testStringification(JsonError::symbol, #symbol)
+  testStringification(DeserializationError::symbol, #symbol)
 
 #define TEST_BOOLIFICATION(symbol, expected) \
-  testBoolification(JsonError::symbol, expected)
+  testBoolification(DeserializationError::symbol, expected)
 
-TEST_CASE("JsonError") {
+TEST_CASE("DeserializationError") {
   SECTION("c_str()") {
     TEST_STRINGIFICATION(Ok);
     TEST_STRINGIFICATION(TooDeep);
     TEST_STRINGIFICATION(NoMemory);
     TEST_STRINGIFICATION(InvalidInput);
     TEST_STRINGIFICATION(IncompleteInput);
+    TEST_STRINGIFICATION(NotSupported);
   }
 
   SECTION("as boolean") {
@@ -34,11 +35,12 @@ TEST_CASE("JsonError") {
     TEST_BOOLIFICATION(NoMemory, true);
     TEST_BOOLIFICATION(InvalidInput, true);
     TEST_BOOLIFICATION(IncompleteInput, true);
+    TEST_BOOLIFICATION(NotSupported, true);
   }
 
   SECTION("ostream") {
     std::stringstream s;
-    s << JsonError::InvalidInput;
+    s << DeserializationError::InvalidInput;
     REQUIRE(s.str() == "InvalidInput");
   }
 }

test/JsonDeserializer/deserializeJsonArray.cpp

@@ -9,36 +9,36 @@ TEST_CASE("deserialize JSON array") {
   DynamicJsonDocument doc;
 
   SECTION("An empty array") {
-    JsonError err = deserializeJson(doc, "[]");
+    DeserializationError err = deserializeJson(doc, "[]");
     JsonArray& arr = doc.as<JsonArray>();
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(0 == arr.size());
   }
 
   SECTION("Spaces") {
     SECTION("Before the opening bracket") {
-      JsonError err = deserializeJson(doc, "  []");
+      DeserializationError err = deserializeJson(doc, "  []");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(0 == arr.size());
     }
 
     SECTION("Before first value") {
-      JsonError err = deserializeJson(doc, "[ \t\r\n42]");
+      DeserializationError err = deserializeJson(doc, "[ \t\r\n42]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == 42);
     }
 
     SECTION("After first value") {
-      JsonError err = deserializeJson(doc, "[42 \t\r\n]");
+      DeserializationError err = deserializeJson(doc, "[42 \t\r\n]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == 42);
     }
@@ -46,58 +46,58 @@ TEST_CASE("deserialize JSON array") {
 
   SECTION("Values types") {
     SECTION("On integer") {
-      JsonError err = deserializeJson(doc, "[42]");
+      DeserializationError err = deserializeJson(doc, "[42]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == 42);
     }
 
     SECTION("Two integers") {
-      JsonError err = deserializeJson(doc, "[42,84]");
+      DeserializationError err = deserializeJson(doc, "[42,84]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == 42);
       REQUIRE(arr[1] == 84);
     }
 
     SECTION("Double") {
-      JsonError err = deserializeJson(doc, "[4.2,1e2]");
+      DeserializationError err = deserializeJson(doc, "[4.2,1e2]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == 4.2);
       REQUIRE(arr[1] == 1e2);
     }
 
     SECTION("Unsigned long") {
-      JsonError err = deserializeJson(doc, "[4294967295]");
+      DeserializationError err = deserializeJson(doc, "[4294967295]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == 4294967295UL);
     }
 
     SECTION("Boolean") {
-      JsonError err = deserializeJson(doc, "[true,false]");
+      DeserializationError err = deserializeJson(doc, "[true,false]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == true);
       REQUIRE(arr[1] == false);
     }
 
     SECTION("Null") {
-      JsonError err = deserializeJson(doc, "[null,null]");
+      DeserializationError err = deserializeJson(doc, "[null,null]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0].as<char*>() == 0);
       REQUIRE(arr[1].as<char*>() == 0);
@@ -106,232 +106,241 @@ TEST_CASE("deserialize JSON array") {
 
   SECTION("Quotes") {
     SECTION("Double quotes") {
-      JsonError err = deserializeJson(doc, "[ \"hello\" , \"world\" ]");
+      DeserializationError err =
+          deserializeJson(doc, "[ \"hello\" , \"world\" ]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("Single quotes") {
-      JsonError err = deserializeJson(doc, "[ 'hello' , 'world' ]");
+      DeserializationError err = deserializeJson(doc, "[ 'hello' , 'world' ]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("No quotes") {
-      JsonError err = deserializeJson(doc, "[ hello , world ]");
+      DeserializationError err = deserializeJson(doc, "[ hello , world ]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("Double quotes (empty strings)") {
-      JsonError err = deserializeJson(doc, "[\"\",\"\"]");
+      DeserializationError err = deserializeJson(doc, "[\"\",\"\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "");
       REQUIRE(arr[1] == "");
     }
 
     SECTION("Single quotes (empty strings)") {
-      JsonError err = deserializeJson(doc, "[\'\',\'\']");
+      DeserializationError err = deserializeJson(doc, "[\'\',\'\']");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "");
       REQUIRE(arr[1] == "");
     }
 
     SECTION("No quotes (empty strings)") {
-      JsonError err = deserializeJson(doc, "[,]");
+      DeserializationError err = deserializeJson(doc, "[,]");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("Closing single quotes missing") {
-      JsonError err = deserializeJson(doc, "[\"]");
+      DeserializationError err = deserializeJson(doc, "[\"]");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("Closing double quotes missing") {
-      JsonError err = deserializeJson(doc, "[\']");
+      DeserializationError err = deserializeJson(doc, "[\']");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
   SECTION("Block comments") {
     SECTION("Before opening bracket") {
-      JsonError err = deserializeJson(doc, "/*COMMENT*/  [\"hello\"]");
+      DeserializationError err =
+          deserializeJson(doc, "/*COMMENT*/  [\"hello\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("After opening bracket") {
-      JsonError err = deserializeJson(doc, "[/*COMMENT*/ \"hello\"]");
+      DeserializationError err =
+          deserializeJson(doc, "[/*COMMENT*/ \"hello\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("Before closing bracket") {
-      JsonError err = deserializeJson(doc, "[\"hello\"/*COMMENT*/]");
+      DeserializationError err = deserializeJson(doc, "[\"hello\"/*COMMENT*/]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("After closing bracket") {
-      JsonError err = deserializeJson(doc, "[\"hello\"]/*COMMENT*/");
+      DeserializationError err = deserializeJson(doc, "[\"hello\"]/*COMMENT*/");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("Before comma") {
-      JsonError err = deserializeJson(doc, "[\"hello\"/*COMMENT*/,\"world\"]");
+      DeserializationError err =
+          deserializeJson(doc, "[\"hello\"/*COMMENT*/,\"world\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(doc, "[\"hello\",/*COMMENT*/ \"world\"]");
+      DeserializationError err =
+          deserializeJson(doc, "[\"hello\",/*COMMENT*/ \"world\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("/*/") {
-      JsonError err = deserializeJson(doc, "[/*/\n]");
-      REQUIRE(err == JsonError::IncompleteInput);
+      DeserializationError err = deserializeJson(doc, "[/*/\n]");
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("Unfinished comment") {
-      JsonError err = deserializeJson(doc, "[/*COMMENT]");
-      REQUIRE(err == JsonError::IncompleteInput);
+      DeserializationError err = deserializeJson(doc, "[/*COMMENT]");
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("Final slash missing") {
-      JsonError err = deserializeJson(doc, "[/*COMMENT*]");
-      REQUIRE(err == JsonError::IncompleteInput);
+      DeserializationError err = deserializeJson(doc, "[/*COMMENT*]");
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
   SECTION("Trailing comments") {
     SECTION("Before opening bracket") {
-      JsonError err = deserializeJson(doc, "//COMMENT\n\t[\"hello\"]");
+      DeserializationError err =
+          deserializeJson(doc, "//COMMENT\n\t[\"hello\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("After opening bracket") {
-      JsonError err = deserializeJson(doc, "[//COMMENT\n\"hello\"]");
+      DeserializationError err = deserializeJson(doc, "[//COMMENT\n\"hello\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("Before closing bracket") {
-      JsonError err = deserializeJson(doc, "[\"hello\"//COMMENT\r\n]");
+      DeserializationError err =
+          deserializeJson(doc, "[\"hello\"//COMMENT\r\n]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("After closing bracket") {
-      JsonError err = deserializeJson(doc, "[\"hello\"]//COMMENT\n");
+      DeserializationError err = deserializeJson(doc, "[\"hello\"]//COMMENT\n");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(1 == arr.size());
       REQUIRE(arr[0] == "hello");
     }
 
     SECTION("Before comma") {
-      JsonError err = deserializeJson(doc, "[\"hello\"//COMMENT\n,\"world\"]");
+      DeserializationError err =
+          deserializeJson(doc, "[\"hello\"//COMMENT\n,\"world\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(doc, "[\"hello\",//COMMENT\n\"world\"]");
+      DeserializationError err =
+          deserializeJson(doc, "[\"hello\",//COMMENT\n\"world\"]");
       JsonArray& arr = doc.as<JsonArray>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
       REQUIRE(arr[0] == "hello");
       REQUIRE(arr[1] == "world");
     }
 
     SECTION("Invalid comment") {
-      JsonError err = deserializeJson(doc, "[/COMMENT\n]");
-      REQUIRE(err == JsonError::InvalidInput);
+      DeserializationError err = deserializeJson(doc, "[/COMMENT\n]");
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("End document with comment") {
-      JsonError err = deserializeJson(doc, "[//COMMENT");
-      REQUIRE(err == JsonError::IncompleteInput);
+      DeserializationError err = deserializeJson(doc, "[//COMMENT");
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
   SECTION("Premature null-terminator") {
     SECTION("After opening bracket") {
-      JsonError err = deserializeJson(doc, "[");
+      DeserializationError err = deserializeJson(doc, "[");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After value") {
-      JsonError err = deserializeJson(doc, "[1");
+      DeserializationError err = deserializeJson(doc, "[1");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(doc, "[1,");
+      DeserializationError err = deserializeJson(doc, "[1,");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
@@ -339,21 +348,21 @@ TEST_CASE("deserialize JSON array") {
     const char* input = "[1,2]";
 
     SECTION("After opening bracket") {
-      JsonError err = deserializeJson(doc, input, 1);
+      DeserializationError err = deserializeJson(doc, input, 1);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After value") {
-      JsonError err = deserializeJson(doc, input, 2);
+      DeserializationError err = deserializeJson(doc, input, 2);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(doc, input, 3);
+      DeserializationError err = deserializeJson(doc, input, 3);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
@@ -362,14 +371,14 @@ TEST_CASE("deserialize JSON array") {
       char jsonString[] =
           " [ { \"a\" : 1 , \"b\" : 2 } , { \"c\" : 3 , \"d\" : 4 } ] ";
 
-      JsonError err = deserializeJson(doc, jsonString);
+      DeserializationError err = deserializeJson(doc, jsonString);
       JsonArray& arr = doc.as<JsonArray>();
 
       JsonObject& object1 = arr[0];
       const JsonObject& object2 = arr[1];
       JsonObject& object3 = arr[2];
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
 
       REQUIRE(true == object1.success());
       REQUIRE(true == object2.success());

test/JsonDeserializer/deserializeJsonArrayStatic.cpp

@@ -10,45 +10,45 @@ TEST_CASE("deserialize JSON array with a StaticJsonDocument") {
     StaticJsonDocument<JSON_ARRAY_SIZE(0)> doc;
     char input[] = "[]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("TooSmallBufferForArrayWithOneValue") {
     StaticJsonDocument<JSON_ARRAY_SIZE(1) - 1> doc;
     char input[] = "[1]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::NoMemory);
+    REQUIRE(err == DeserializationError::NoMemory);
   }
 
   SECTION("BufferOfTheRightSizeForArrayWithOneValue") {
     StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
     char input[] = "[1]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("TooSmallBufferForArrayWithNestedObject") {
     StaticJsonDocument<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0) - 1> doc;
     char input[] = "[{}]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::NoMemory);
+    REQUIRE(err == DeserializationError::NoMemory);
   }
 
   SECTION("BufferOfTheRightSizeForArrayWithNestedObject") {
     StaticJsonDocument<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)> doc;
     char input[] = "[{}]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("CopyStringNotSpaces") {
@@ -77,10 +77,10 @@ TEST_CASE("deserialize JSON array with a StaticJsonDocument") {
     StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
     char input[] = "[1,2]";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
     JsonArray& arr = doc.as<JsonArray>();
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<JsonArray>());
     REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
     REQUIRE(arr[0] == 1);

test/JsonDeserializer/deserializeJsonObject.cpp

@@ -9,50 +9,50 @@ TEST_CASE("deserialize JSON object") {
   DynamicJsonDocument doc;
 
   SECTION("An empty object") {
-    JsonError err = deserializeJson(doc, "{}");
+    DeserializationError err = deserializeJson(doc, "{}");
     JsonObject& obj = doc.as<JsonObject>();
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<JsonObject>());
     REQUIRE(obj.size() == 0);
   }
 
   SECTION("Quotes") {
     SECTION("Double quotes") {
-      JsonError err = deserializeJson(doc, "{\"key\":\"value\"}");
+      DeserializationError err = deserializeJson(doc, "{\"key\":\"value\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("Single quotes") {
-      JsonError err = deserializeJson(doc, "{'key':'value'}");
+      DeserializationError err = deserializeJson(doc, "{'key':'value'}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("No quotes") {
-      JsonError err = deserializeJson(doc, "{key:value}");
+      DeserializationError err = deserializeJson(doc, "{key:value}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("No quotes, allow underscore in key") {
-      JsonError err = deserializeJson(doc, "{_k_e_y_:42}");
+      DeserializationError err = deserializeJson(doc, "{_k_e_y_:42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["_k_e_y_"] == 42);
@@ -61,51 +61,51 @@ TEST_CASE("deserialize JSON object") {
 
   SECTION("Spaces") {
     SECTION("Before the key") {
-      JsonError err = deserializeJson(doc, "{ \"key\":\"value\"}");
+      DeserializationError err = deserializeJson(doc, "{ \"key\":\"value\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("After the key") {
-      JsonError err = deserializeJson(doc, "{\"key\" :\"value\"}");
+      DeserializationError err = deserializeJson(doc, "{\"key\" :\"value\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("Before the value") {
-      JsonError err = deserializeJson(doc, "{\"key\": \"value\"}");
+      DeserializationError err = deserializeJson(doc, "{\"key\": \"value\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("After the value") {
-      JsonError err = deserializeJson(doc, "{\"key\":\"value\" }");
+      DeserializationError err = deserializeJson(doc, "{\"key\":\"value\" }");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 1);
       REQUIRE(obj["key"] == "value");
     }
 
     SECTION("Before the colon") {
-      JsonError err =
+      DeserializationError err =
           deserializeJson(doc, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == "value1");
@@ -113,11 +113,11 @@ TEST_CASE("deserialize JSON object") {
     }
 
     SECTION("After the colon") {
-      JsonError err =
+      DeserializationError err =
           deserializeJson(doc, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == "value1");
@@ -127,11 +127,11 @@ TEST_CASE("deserialize JSON object") {
 
   SECTION("Values types") {
     SECTION("String") {
-      JsonError err =
+      DeserializationError err =
           deserializeJson(doc, "{\"key1\":\"value1\",\"key2\":\"value2\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == "value1");
@@ -139,10 +139,11 @@ TEST_CASE("deserialize JSON object") {
     }
 
     SECTION("Integer") {
-      JsonError err = deserializeJson(doc, "{\"key1\":42,\"key2\":-42}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"key1\":42,\"key2\":-42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == 42);
@@ -150,10 +151,11 @@ TEST_CASE("deserialize JSON object") {
     }
 
     SECTION("Double") {
-      JsonError err = deserializeJson(doc, "{\"key1\":12.345,\"key2\":-7E89}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"key1\":12.345,\"key2\":-7E89}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == 12.345);
@@ -161,10 +163,11 @@ TEST_CASE("deserialize JSON object") {
     }
 
     SECTION("Booleans") {
-      JsonError err = deserializeJson(doc, "{\"key1\":true,\"key2\":false}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"key1\":true,\"key2\":false}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"] == true);
@@ -172,10 +175,11 @@ TEST_CASE("deserialize JSON object") {
     }
 
     SECTION("Null") {
-      JsonError err = deserializeJson(doc, "{\"key1\":null,\"key2\":null}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"key1\":null,\"key2\":null}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
       REQUIRE(obj["key1"].as<char*>() == 0);
@@ -185,14 +189,14 @@ TEST_CASE("deserialize JSON object") {
     SECTION("Array") {
       char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } ";
 
-      JsonError err = deserializeJson(doc, jsonString);
+      DeserializationError err = deserializeJson(doc, jsonString);
       JsonObject& obj = doc.as<JsonObject>();
 
       JsonArray& array1 = obj["ab"];
       const JsonArray& array2 = obj["cd"];
       JsonArray& array3 = obj["ef"];
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
 
       REQUIRE(true == array1.success());
       REQUIRE(true == array2.success());
@@ -214,127 +218,133 @@ TEST_CASE("deserialize JSON object") {
 
   SECTION("Premature null terminator") {
     SECTION("After opening brace") {
-      JsonError err = deserializeJson(doc, "{");
+      DeserializationError err = deserializeJson(doc, "{");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After key") {
-      JsonError err = deserializeJson(doc, "{\"hello\"");
+      DeserializationError err = deserializeJson(doc, "{\"hello\"");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\":");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After value") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":\"world\"");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\",");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":\"world\",");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
   SECTION("Misc") {
     SECTION("A quoted key without value") {
-      JsonError err = deserializeJson(doc, "{\"key\"}");
+      DeserializationError err = deserializeJson(doc, "{\"key\"}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("A non-quoted key without value") {
-      JsonError err = deserializeJson(doc, "{key}");
+      DeserializationError err = deserializeJson(doc, "{key}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("A dangling comma") {
-      JsonError err = deserializeJson(doc, "{\"key1\":\"value1\",}");
+      DeserializationError err = deserializeJson(doc, "{\"key1\":\"value1\",}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("null as a key") {
-      JsonError err = deserializeJson(doc, "{null:\"value\"}");
+      DeserializationError err = deserializeJson(doc, "{null:\"value\"}");
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
     }
   }
 
   SECTION("Block comments") {
     SECTION("Before opening brace") {
-      JsonError err = deserializeJson(doc, "/*COMMENT*/ {\"hello\":\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "/*COMMENT*/ {\"hello\":\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After opening brace") {
-      JsonError err = deserializeJson(doc, "{/*COMMENT*/\"hello\":\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{/*COMMENT*/\"hello\":\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\"/*COMMENT*/:\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\"/*COMMENT*/:\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\":/*COMMENT*/\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\":/*COMMENT*/\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"/*COMMENT*/}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\":\"world\"/*COMMENT*/}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"}/*COMMENT*/");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\":\"world\"}/*COMMENT*/");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before comma") {
-      JsonError err = deserializeJson(
+      DeserializationError err = deserializeJson(
           doc, "{\"hello\":\"world\"/*COMMENT*/,\"answer\":42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
       REQUIRE(obj["answer"] == 42);
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(
+      DeserializationError err = deserializeJson(
           doc, "{\"hello\":\"world\",/*COMMENT*/\"answer\":42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
       REQUIRE(obj["answer"] == 42);
     }
@@ -342,69 +352,75 @@ TEST_CASE("deserialize JSON object") {
 
   SECTION("Trailing comments") {
     SECTION("Before opening brace") {
-      JsonError err = deserializeJson(doc, "//COMMENT\n {\"hello\":\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "//COMMENT\n {\"hello\":\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After opening brace") {
-      JsonError err = deserializeJson(doc, "{//COMMENT\n\"hello\":\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{//COMMENT\n\"hello\":\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\"//COMMENT\n:\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\"//COMMENT\n:\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\"://COMMENT\n\"world\"}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\"://COMMENT\n\"world\"}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"//COMMENT\n}");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\":\"world\"//COMMENT\n}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("After closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"}//COMMENT\n");
+      DeserializationError err =
+          deserializeJson(doc, "{\"hello\":\"world\"}//COMMENT\n");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before comma") {
-      JsonError err = deserializeJson(
+      DeserializationError err = deserializeJson(
           doc, "{\"hello\":\"world\"//COMMENT\n,\"answer\":42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
       REQUIRE(obj["answer"] == 42);
     }
 
     SECTION("After comma") {
-      JsonError err = deserializeJson(
+      DeserializationError err = deserializeJson(
           doc, "{\"hello\":\"world\",//COMMENT\n\"answer\":42}");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
       REQUIRE(obj["answer"] == 42);
     }
@@ -412,55 +428,55 @@ TEST_CASE("deserialize JSON object") {
 
   SECTION("Dangling slash") {
     SECTION("Before opening brace") {
-      JsonError err = deserializeJson(doc, "/{\"hello\":\"world\"}");
+      DeserializationError err = deserializeJson(doc, "/{\"hello\":\"world\"}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("After opening brace") {
-      JsonError err = deserializeJson(doc, "{/\"hello\":\"world\"}");
+      DeserializationError err = deserializeJson(doc, "{/\"hello\":\"world\"}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("Before colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\"/:\"world\"}");
+      DeserializationError err = deserializeJson(doc, "{\"hello\"/:\"world\"}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("After colon") {
-      JsonError err = deserializeJson(doc, "{\"hello\":/\"world\"}");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":/\"world\"}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("Before closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"/}");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":\"world\"/}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("After closing brace") {
-      JsonError err = deserializeJson(doc, "{\"hello\":\"world\"}/");
+      DeserializationError err = deserializeJson(doc, "{\"hello\":\"world\"}/");
       JsonObject& obj = doc.as<JsonObject>();
 
-      REQUIRE(err == JsonError::Ok);
+      REQUIRE(err == DeserializationError::Ok);
       REQUIRE(obj["hello"] == "world");
     }
 
     SECTION("Before comma") {
-      JsonError err =
+      DeserializationError err =
           deserializeJson(doc, "{\"hello\":\"world\"/,\"answer\":42}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
 
     SECTION("After comma") {
-      JsonError err =
+      DeserializationError err =
           deserializeJson(doc, "{\"hello\":\"world\",/\"answer\":42}");
 
-      REQUIRE(err == JsonError::InvalidInput);
+      REQUIRE(err == DeserializationError::InvalidInput);
     }
   }
 

test/JsonDeserializer/deserializeJsonObjectStatic.cpp

@@ -10,45 +10,45 @@ TEST_CASE("deserialize JSON object with StaticJsonDocument") {
     StaticJsonDocument<JSON_OBJECT_SIZE(0)> doc;
     char input[] = "{}";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("TooSmallBufferForObjectWithOneValue") {
     StaticJsonDocument<JSON_OBJECT_SIZE(1) - 1> doc;
     char input[] = "{\"a\":1}";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::NoMemory);
+    REQUIRE(err == DeserializationError::NoMemory);
   }
 
   SECTION("BufferOfTheRightSizeForObjectWithOneValue") {
     StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
     char input[] = "{\"a\":1}";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("TooSmallBufferForObjectWithNestedObject") {
     StaticJsonDocument<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0) - 1> doc;
     char input[] = "{\"a\":[]}";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::NoMemory);
+    REQUIRE(err == DeserializationError::NoMemory);
   }
 
   SECTION("BufferOfTheRightSizeForObjectWithNestedObject") {
     StaticJsonDocument<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)> doc;
     char input[] = "{\"a\":[]}";
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("Should clear the JsonObject") {

test/JsonDeserializer/deserializeJsonValue.cpp

@@ -11,71 +11,78 @@ TEST_CASE("deserializeJson(DynamicJsonDocument&)") {
   DynamicJsonDocument doc;
 
   SECTION("null char*") {
-    JsonError err = deserializeJson(doc, static_cast<char*>(0));
+    DeserializationError err = deserializeJson(doc, static_cast<char*>(0));
 
-    REQUIRE(err != JsonError::Ok);
+    REQUIRE(err != DeserializationError::Ok);
   }
 
   SECTION("null const char*") {
-    JsonError err = deserializeJson(doc, static_cast<const char*>(0));
+    DeserializationError err =
+        deserializeJson(doc, static_cast<const char*>(0));
 
-    REQUIRE(err != JsonError::Ok);
+    REQUIRE(err != DeserializationError::Ok);
   }
 
   SECTION("Integer") {
-    JsonError err = deserializeJson(doc, "-42");
+    DeserializationError err = deserializeJson(doc, "-42");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<int>());
     REQUIRE_FALSE(doc.is<bool>());
     REQUIRE(doc.as<int>() == -42);
   }
 
   SECTION("Double") {
-    JsonError err = deserializeJson(doc, "-1.23e+4");
+    DeserializationError err = deserializeJson(doc, "-1.23e+4");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE_FALSE(doc.is<int>());
     REQUIRE(doc.is<double>());
     REQUIRE(doc.as<double>() == Approx(-1.23e+4));
   }
 
   SECTION("Double quoted string") {
-    JsonError err = deserializeJson(doc, "\"hello world\"");
+    DeserializationError err = deserializeJson(doc, "\"hello world\"");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<char*>());
     REQUIRE_THAT(doc.as<char*>(), Equals("hello world"));
   }
 
   SECTION("Single quoted string") {
-    JsonError err = deserializeJson(doc, "\'hello world\'");
+    DeserializationError err = deserializeJson(doc, "\'hello world\'");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<char*>());
     REQUIRE_THAT(doc.as<char*>(), Equals("hello world"));
   }
 
   SECTION("Escape sequences") {
-    JsonError err =
+    DeserializationError err =
         deserializeJson(doc, "\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.as<std::string>() == "1\"2\\3/4\b5\f6\n7\r8\t9");
   }
 
-  SECTION("True") {
-    JsonError err = deserializeJson(doc, "true");
+  SECTION("UTF-16 surrogate") {
+    DeserializationError err = deserializeJson(doc, "\"\\uD834\\uDD1E\"");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::NotSupported);
+  }
+
+  SECTION("True") {
+    DeserializationError err = deserializeJson(doc, "true");
+
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<bool>());
     REQUIRE(doc.as<bool>() == true);
   }
 
   SECTION("False") {
-    JsonError err = deserializeJson(doc, "false");
+    DeserializationError err = deserializeJson(doc, "false");
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<bool>());
     REQUIRE(doc.as<bool>() == false);
   }
@@ -89,84 +96,84 @@ TEST_CASE("deserializeJson(DynamicJsonDocument&)") {
   }
 
   SECTION("Empty input") {
-    JsonError err = deserializeJson(doc, "");
+    DeserializationError err = deserializeJson(doc, "");
 
-    REQUIRE(err == JsonError::IncompleteInput);
+    REQUIRE(err == DeserializationError::IncompleteInput);
   }
 
   SECTION("Just a trailing comment") {
-    JsonError err = deserializeJson(doc, "// comment");
+    DeserializationError err = deserializeJson(doc, "// comment");
 
-    REQUIRE(err == JsonError::IncompleteInput);
+    REQUIRE(err == DeserializationError::IncompleteInput);
   }
 
   SECTION("Just a block comment") {
-    JsonError err = deserializeJson(doc, "/*comment*/");
+    DeserializationError err = deserializeJson(doc, "/*comment*/");
 
-    REQUIRE(err == JsonError::IncompleteInput);
+    REQUIRE(err == DeserializationError::IncompleteInput);
   }
 
   SECTION("Just a slash") {
-    JsonError err = deserializeJson(doc, "/");
+    DeserializationError err = deserializeJson(doc, "/");
 
-    REQUIRE(err == JsonError::InvalidInput);
+    REQUIRE(err == DeserializationError::InvalidInput);
   }
 
   SECTION("Garbage") {
-    JsonError err = deserializeJson(doc, "%*$£¤");
+    DeserializationError err = deserializeJson(doc, "%*$£¤");
 
-    REQUIRE(err == JsonError::InvalidInput);
+    REQUIRE(err == DeserializationError::InvalidInput);
   }
 
   SECTION("Premature null-terminator") {
     SECTION("In escape sequence") {
-      JsonError err = deserializeJson(doc, "\"\\");
+      DeserializationError err = deserializeJson(doc, "\"\\");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In block comment") {
-      JsonError err = deserializeJson(doc, "/* comment");
+      DeserializationError err = deserializeJson(doc, "/* comment");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In double quoted string") {
-      JsonError err = deserializeJson(doc, "\"hello");
+      DeserializationError err = deserializeJson(doc, "\"hello");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In single quoted string") {
-      JsonError err = deserializeJson(doc, "'hello");
+      DeserializationError err = deserializeJson(doc, "'hello");
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 
   SECTION("Premature end of input") {
     SECTION("In escape sequence") {
-      JsonError err = deserializeJson(doc, "\"\\n\"", 2);
+      DeserializationError err = deserializeJson(doc, "\"\\n\"", 2);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In block comment") {
-      JsonError err = deserializeJson(doc, "/* comment */", 10);
+      DeserializationError err = deserializeJson(doc, "/* comment */", 10);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In double quoted string") {
-      JsonError err = deserializeJson(doc, "\"hello\"", 6);
+      DeserializationError err = deserializeJson(doc, "\"hello\"", 6);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
 
     SECTION("In single quoted string") {
-      JsonError err = deserializeJson(doc, "'hello'", 6);
+      DeserializationError err = deserializeJson(doc, "'hello'", 6);
 
-      REQUIRE(err == JsonError::IncompleteInput);
+      REQUIRE(err == DeserializationError::IncompleteInput);
     }
   }
 }

test/JsonDeserializer/nestingLimit.cpp

@@ -5,8 +5,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
-#define SHOULD_WORK(expression) REQUIRE(JsonError::Ok == expression);
-#define SHOULD_FAIL(expression) REQUIRE(JsonError::TooDeep == expression);
+#define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression);
+#define SHOULD_FAIL(expression) \
+  REQUIRE(DeserializationError::TooDeep == expression);
 
 TEST_CASE("JsonDeserializer nestingLimit") {
   DynamicJsonDocument doc;

test/JsonDeserializer/std_istream.cpp

@@ -12,10 +12,10 @@ TEST_CASE("deserializeJson(std::istream&)") {
   SECTION("array") {
     std::istringstream json(" [ 42 /* comment */ ] ");
 
-    JsonError err = deserializeJson(doc, json);
+    DeserializationError err = deserializeJson(doc, json);
     JsonArray& arr = doc.as<JsonArray>();
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(1 == arr.size());
     REQUIRE(42 == arr[0]);
   }
@@ -23,10 +23,10 @@ TEST_CASE("deserializeJson(std::istream&)") {
   SECTION("object") {
     std::istringstream json(" { hello : world // comment\n }");
 
-    JsonError err = deserializeJson(doc, json);
+    DeserializationError err = deserializeJson(doc, json);
     JsonObject& obj = doc.as<JsonObject>();
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(1 == obj.size());
     REQUIRE(std::string("world") == obj["hello"]);
   }

test/JsonDeserializer/std_string.cpp

@@ -11,25 +11,25 @@ TEST_CASE("deserializeJson(const std::string&)") {
   SECTION("should accept const string") {
     const std::string input("[42]");
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("should accept temporary string") {
-    JsonError err = deserializeJson(doc, std::string("[42]"));
+    DeserializationError err = deserializeJson(doc, std::string("[42]"));
 
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
   }
 
   SECTION("should duplicate content") {
     std::string input("[\"hello\"]");
 
-    JsonError err = deserializeJson(doc, input);
+    DeserializationError err = deserializeJson(doc, input);
     input[2] = 'X';  // alter the string tomake sure we made a copy
 
     JsonArray &array = doc.as<JsonArray>();
-    REQUIRE(err == JsonError::Ok);
+    REQUIRE(err == DeserializationError::Ok);
     REQUIRE(std::string("hello") == array[0]);
   }
 }