mirror of
https://github.com/eledio-devices/thirdparty-ArduinoJson.git
synced 2025-11-01 00:38:27 +01:00
Changed unit testing framework from Google Test to Catch
This commit is contained in:
Benoit Blanchon
@@ -13,5 +13,5 @@ add_executable(JsonBufferTests
|
||||
parseObject.cpp
|
||||
)
|
||||
|
||||
target_link_libraries(JsonBufferTests gtest)
|
||||
target_link_libraries(JsonBufferTests catch)
|
||||
add_test(JsonBuffer JsonBufferTests)
|
||||
|
||||
@@ -6,59 +6,61 @@
|
||||
// If you like this project, please add a star!
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <catch.hpp>
|
||||
|
||||
TEST(JsonParser_Nested_Tests, ArrayNestedInObject) {
|
||||
DynamicJsonBuffer jsonBuffer;
|
||||
char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } ";
|
||||
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"];
|
||||
JsonObject &object = jsonBuffer.parseObject(jsonString);
|
||||
JsonArray &array1 = object["ab"];
|
||||
const JsonArray &array2 = object["cd"];
|
||||
JsonArray &array3 = object["ef"];
|
||||
|
||||
ASSERT_TRUE(object.success());
|
||||
REQUIRE(true == object.success());
|
||||
|
||||
ASSERT_TRUE(array1.success());
|
||||
ASSERT_TRUE(array2.success());
|
||||
ASSERT_FALSE(array3.success());
|
||||
REQUIRE(true == array1.success());
|
||||
REQUIRE(true == array2.success());
|
||||
REQUIRE(false == array3.success());
|
||||
|
||||
ASSERT_EQ(2, array1.size());
|
||||
ASSERT_EQ(2, array2.size());
|
||||
ASSERT_EQ(0, array3.size());
|
||||
REQUIRE(2 == array1.size());
|
||||
REQUIRE(2 == array2.size());
|
||||
REQUIRE(0 == array3.size());
|
||||
|
||||
EXPECT_EQ(1, array1[0].as<int>());
|
||||
EXPECT_EQ(2, array1[1].as<int>());
|
||||
REQUIRE(1 == array1[0].as<int>());
|
||||
REQUIRE(2 == array1[1].as<int>());
|
||||
|
||||
EXPECT_EQ(3, array2[0].as<int>());
|
||||
EXPECT_EQ(4, array2[1].as<int>());
|
||||
REQUIRE(3 == array2[0].as<int>());
|
||||
REQUIRE(4 == array2[1].as<int>());
|
||||
|
||||
EXPECT_EQ(0, array3[0].as<int>());
|
||||
}
|
||||
|
||||
TEST(JsonParser_Nested_Tests, 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];
|
||||
|
||||
ASSERT_TRUE(array.success());
|
||||
|
||||
ASSERT_TRUE(object1.success());
|
||||
ASSERT_TRUE(object2.success());
|
||||
ASSERT_FALSE(object3.success());
|
||||
|
||||
ASSERT_EQ(2, object1.size());
|
||||
ASSERT_EQ(2, object2.size());
|
||||
ASSERT_EQ(0, object3.size());
|
||||
|
||||
EXPECT_EQ(1, object1["a"].as<int>());
|
||||
EXPECT_EQ(2, object1["b"].as<int>());
|
||||
EXPECT_EQ(3, object2["c"].as<int>());
|
||||
EXPECT_EQ(4, object2["d"].as<int>());
|
||||
EXPECT_EQ(0, object3["e"].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>());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,80 +6,46 @@
|
||||
// If you like this project, please add a star!
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <catch.hpp>
|
||||
|
||||
class JsonParser_NestingLimit_Tests : public testing::Test {
|
||||
protected:
|
||||
void whenNestingLimitIs(uint8_t nestingLimit) {
|
||||
_nestingLimit = nestingLimit;
|
||||
}
|
||||
|
||||
void parseArrayMustFail(const char *json) {
|
||||
ASSERT_FALSE(tryParseArray(json));
|
||||
}
|
||||
|
||||
void parseArrayMustSucceed(const char *json) {
|
||||
ASSERT_TRUE(tryParseArray(json));
|
||||
}
|
||||
|
||||
void parseObjectMustFail(const char *json) {
|
||||
ASSERT_FALSE(tryParseObject(json));
|
||||
}
|
||||
|
||||
void parseObjectMustSucceed(const char *json) {
|
||||
ASSERT_TRUE(tryParseObject(json));
|
||||
}
|
||||
|
||||
private:
|
||||
bool tryParseArray(const char *json) {
|
||||
DynamicJsonBuffer buffer;
|
||||
char s[256];
|
||||
strcpy(s, json);
|
||||
return buffer.parseArray(s, _nestingLimit).success();
|
||||
}
|
||||
|
||||
bool tryParseObject(const char *json) {
|
||||
DynamicJsonBuffer buffer;
|
||||
char s[256];
|
||||
strcpy(s, json);
|
||||
return buffer.parseObject(s, _nestingLimit).success();
|
||||
}
|
||||
|
||||
uint8_t _nestingLimit;
|
||||
};
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit0) {
|
||||
whenNestingLimitIs(0);
|
||||
parseArrayMustSucceed("[]");
|
||||
parseArrayMustFail("[[]]");
|
||||
bool tryParseArray(const char *json, uint8_t nestingLimit) {
|
||||
DynamicJsonBuffer buffer;
|
||||
return buffer.parseArray(json, nestingLimit).success();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit1) {
|
||||
whenNestingLimitIs(1);
|
||||
parseArrayMustSucceed("[[]]");
|
||||
parseArrayMustFail("[[[]]]");
|
||||
bool tryParseObject(const char *json, uint8_t nestingLimit) {
|
||||
DynamicJsonBuffer buffer;
|
||||
return buffer.parseObject(json, nestingLimit).success();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit2) {
|
||||
whenNestingLimitIs(2);
|
||||
parseArrayMustSucceed("[[[]]]");
|
||||
parseArrayMustFail("[[[[]]]]");
|
||||
}
|
||||
TEST_CASE("JsonParser nestingLimit") {
|
||||
SECTION("ParseArrayWithNestingLimit0") {
|
||||
REQUIRE(true == tryParseArray("[]", 0));
|
||||
REQUIRE(false == tryParseArray("[[]]", 0));
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit0) {
|
||||
whenNestingLimitIs(0);
|
||||
parseObjectMustSucceed("{}");
|
||||
parseObjectMustFail("{\"key\":{}}");
|
||||
}
|
||||
SECTION("ParseArrayWithNestingLimit1") {
|
||||
REQUIRE(true == tryParseArray("[[]]", 1));
|
||||
REQUIRE(false == tryParseArray("[[[]]]", 1));
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit1) {
|
||||
whenNestingLimitIs(1);
|
||||
parseObjectMustSucceed("{\"key\":{}}");
|
||||
parseObjectMustFail("{\"key\":{\"key\":{}}}");
|
||||
}
|
||||
SECTION("ParseArrayWithNestingLimit2") {
|
||||
REQUIRE(true == tryParseArray("[[[]]]", 2));
|
||||
REQUIRE(false == tryParseArray("[[[[]]]]", 2));
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit2) {
|
||||
whenNestingLimitIs(2);
|
||||
parseObjectMustSucceed("{\"key\":{\"key\":{}}}");
|
||||
parseObjectMustFail("{\"key\":{\"key\":{\"key\":{}}}}");
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,100 +6,78 @@
|
||||
// If you like this project, please add a star!
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <catch.hpp>
|
||||
|
||||
class JsonParser_Variant_Test : public testing::Test {
|
||||
protected:
|
||||
void whenInputIs(const char* jsonString) {
|
||||
strcpy(_jsonString, jsonString);
|
||||
_result = _jsonBuffer.parse(_jsonString);
|
||||
using namespace Catch::Matchers;
|
||||
|
||||
TEST_CASE("JsonBuffer::parse()") {
|
||||
DynamicJsonBuffer jb;
|
||||
|
||||
SECTION("EmptyObject") {
|
||||
JsonVariant variant = jb.parse("{}");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<JsonObject>());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void resultMustEqual(T expected) {
|
||||
EXPECT_EQ(expected, _result.as<T>());
|
||||
SECTION("EmptyArray") {
|
||||
JsonVariant variant = jb.parse("[]");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<JsonArray>());
|
||||
}
|
||||
|
||||
void resultMustEqual(const char* expected) {
|
||||
EXPECT_STREQ(expected, _result.as<char*>());
|
||||
SECTION("Integer") {
|
||||
JsonVariant variant = jb.parse("-42");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<int>());
|
||||
REQUIRE_FALSE(variant.is<double>());
|
||||
REQUIRE(variant == -42);
|
||||
}
|
||||
|
||||
void resultMustEqual(double expected) {
|
||||
EXPECT_DOUBLE_EQ(expected, _result.as<double>());
|
||||
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));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void resultTypeMustBe() {
|
||||
EXPECT_TRUE(_result.is<T>());
|
||||
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"));
|
||||
}
|
||||
|
||||
void resultMustBeInvalid() {
|
||||
EXPECT_FALSE(_result.success());
|
||||
}
|
||||
void resultMustBeValid() {
|
||||
EXPECT_TRUE(_result.success());
|
||||
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"));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void verify(const char* input, T expected) {
|
||||
whenInputIs(input);
|
||||
resultMustBeValid();
|
||||
resultTypeMustBe<T>();
|
||||
resultMustEqual(expected);
|
||||
SECTION("True") {
|
||||
JsonVariant variant = jb.parse("true");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<bool>());
|
||||
REQUIRE(variant == true);
|
||||
}
|
||||
|
||||
private:
|
||||
DynamicJsonBuffer _jsonBuffer;
|
||||
JsonVariant _result;
|
||||
char _jsonString[256];
|
||||
};
|
||||
SECTION("False") {
|
||||
JsonVariant variant = jb.parse("false");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<bool>());
|
||||
REQUIRE(variant == false);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, EmptyObject) {
|
||||
whenInputIs("{}");
|
||||
resultMustBeValid();
|
||||
resultTypeMustBe<JsonObject>();
|
||||
}
|
||||
SECTION("OpenBrace") {
|
||||
JsonVariant variant = jb.parse("{");
|
||||
REQUIRE_FALSE(variant.success());
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, EmptyArray) {
|
||||
whenInputIs("[]");
|
||||
resultMustBeValid();
|
||||
resultTypeMustBe<JsonArray>();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, Integer) {
|
||||
verify("42", 42);
|
||||
verify("-42", -42);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, Double) {
|
||||
verify("3.14", 3.14);
|
||||
verify("3.14", 3.14);
|
||||
verify("1E+10", 1E+10);
|
||||
verify("-1E+10", -1E+10);
|
||||
verify("1.234E+10", 1.234E+10);
|
||||
verify("1.79769e+308", 1.79769e+308);
|
||||
verify("-1.79769e+308", -1.79769e+308);
|
||||
verify("1.7976931348623157e+308", 1.7976931348623157e+308);
|
||||
verify("0.017976931348623157e+310", 0.017976931348623157e+310);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, String) {
|
||||
verify("\"hello world\"", "hello world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, True) {
|
||||
verify("true", true);
|
||||
verify("false", false);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, OpenBrace) {
|
||||
whenInputIs("{");
|
||||
resultMustBeInvalid();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Variant_Test, IncompleteStrings) {
|
||||
verify("\"", "");
|
||||
verify("\"hello", "hello");
|
||||
verify("\'", "");
|
||||
verify("\'world", "world");
|
||||
SECTION("Incomplete string") {
|
||||
JsonVariant variant = jb.parse("\"hello");
|
||||
REQUIRE(variant.success());
|
||||
REQUIRE(variant.is<char*>());
|
||||
REQUIRE_THAT(variant.as<char*>(), Equals("hello"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,362 +6,316 @@
|
||||
// If you like this project, please add a star!
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <catch.hpp>
|
||||
|
||||
class JsonParser_Array_Tests : public testing::Test {
|
||||
protected:
|
||||
void whenInputIs(const char *json) {
|
||||
strcpy(_jsonString, json);
|
||||
TEST_CASE("JsonBuffer::parseArray()") {
|
||||
DynamicJsonBuffer jb;
|
||||
|
||||
SECTION("EmptyArray") {
|
||||
JsonArray& arr = jb.parseArray("[]");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(0 == arr.size());
|
||||
}
|
||||
|
||||
void whenInputIs(const char *json, size_t len) {
|
||||
memcpy(_jsonString, json, len);
|
||||
SECTION("MissingOpeningBracket") {
|
||||
JsonArray& arr = jb.parseArray("]");
|
||||
REQUIRE_FALSE(arr.success());
|
||||
}
|
||||
|
||||
void parseMustSucceed() {
|
||||
_array = &_jsonBuffer.parseArray(_jsonString);
|
||||
EXPECT_TRUE(_array->success());
|
||||
SECTION("ArrayWithNoEnd") {
|
||||
JsonArray& arr = jb.parseArray("[");
|
||||
REQUIRE_FALSE(arr.success());
|
||||
}
|
||||
|
||||
void parseMustFail() {
|
||||
_array = &_jsonBuffer.parseArray(_jsonString);
|
||||
EXPECT_FALSE(_array->success());
|
||||
EXPECT_EQ(0, _array->size());
|
||||
SECTION("EmptyArrayWithLeadingSpaces") {
|
||||
JsonArray& arr = jb.parseArray(" []");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(0 == arr.size());
|
||||
}
|
||||
|
||||
void sizeMustBe(int expected) {
|
||||
ASSERT_EQ(expected, _array->size());
|
||||
SECTION("Garbage") {
|
||||
JsonArray& arr = jb.parseArray("%*$£¤");
|
||||
|
||||
REQUIRE_FALSE(arr.success());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void firstElementMustBe(T expected) {
|
||||
elementAtIndexMustBe(0, expected);
|
||||
SECTION("OneInteger") {
|
||||
JsonArray& arr = jb.parseArray("[42]");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(1 == arr.size());
|
||||
REQUIRE(arr[0] == 42);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void secondElementMustBe(T expected) {
|
||||
elementAtIndexMustBe(1, expected);
|
||||
SECTION("OneIntegerWithSpacesBefore") {
|
||||
JsonArray& arr = jb.parseArray("[ \t\r\n42]");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(1 == arr.size());
|
||||
REQUIRE(arr[0] == 42);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void elementAtIndexMustBe(int index, T expected) {
|
||||
EXPECT_EQ(expected, (*_array)[index].as<T>());
|
||||
SECTION("OneIntegerWithSpaceAfter") {
|
||||
JsonArray& arr = jb.parseArray("[42 \t\r\n]");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(1 == arr.size());
|
||||
REQUIRE(arr[0] == 42);
|
||||
}
|
||||
|
||||
void elementAtIndexMustBe(int index, const char *expected) {
|
||||
EXPECT_STREQ(expected, (*_array)[index].as<const char *>());
|
||||
SECTION("TwoIntegers") {
|
||||
JsonArray& arr = jb.parseArray("[42,84]");
|
||||
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(2 == arr.size());
|
||||
REQUIRE(arr[0] == 42);
|
||||
REQUIRE(arr[1] == 84);
|
||||
}
|
||||
|
||||
DynamicJsonBuffer _jsonBuffer;
|
||||
JsonArray *_array;
|
||||
char _jsonString[256];
|
||||
};
|
||||
SECTION("TwoDoubles") {
|
||||
JsonArray& arr = jb.parseArray("[4.2,1e2]");
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EmptyArray) {
|
||||
whenInputIs("[]");
|
||||
REQUIRE(arr.success());
|
||||
REQUIRE(2 == arr.size());
|
||||
REQUIRE(arr[0] == 4.2);
|
||||
REQUIRE(arr[1] == 1e2);
|
||||
}
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(0);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, MissingOpeningBracket) {
|
||||
whenInputIs("]");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, ArrayWithNoEnd) {
|
||||
whenInputIs("[");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EmptyArrayWithLeadingSpaces) {
|
||||
whenInputIs(" []");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(0);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, Garbage) {
|
||||
whenInputIs("%*$£¤");
|
||||
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, OneInteger) {
|
||||
whenInputIs("[42]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe(42);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, OneIntegerWithSpacesBefore) {
|
||||
whenInputIs("[ \t\r\n42]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe(42);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, OneIntegerWithSpaceAfter) {
|
||||
whenInputIs("[42 \t\r\n]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe(42);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoIntegers) {
|
||||
whenInputIs("[42,84]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe(42);
|
||||
secondElementMustBe(84);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoDoubles) {
|
||||
whenInputIs("[4.2,1e2]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe(4.2);
|
||||
secondElementMustBe(1e2);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, UnsignedLong) {
|
||||
whenInputIs("[4294967295]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe(4294967295UL);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoBooleans) {
|
||||
whenInputIs("[true,false]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe(true);
|
||||
secondElementMustBe(false);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoNulls) {
|
||||
const char *const nullCharPtr = 0;
|
||||
|
||||
whenInputIs("[null,null]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe(nullCharPtr);
|
||||
secondElementMustBe(nullCharPtr);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoStringsDoubleQuotes) {
|
||||
whenInputIs("[ \"hello\" , \"world\" ]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoStringsSingleQuotes) {
|
||||
whenInputIs("[ 'hello' , 'world' ]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, TwoStringsNoQuotes) {
|
||||
whenInputIs("[ hello , world ]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EmptyStringsDoubleQuotes) {
|
||||
whenInputIs("[\"\",\"\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("");
|
||||
secondElementMustBe("");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EmptyStringSingleQuotes) {
|
||||
whenInputIs("[\'\',\'\']");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("");
|
||||
secondElementMustBe("");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EmptyStringNoQuotes) {
|
||||
whenInputIs("[,]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("");
|
||||
secondElementMustBe("");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, ClosingDoubleQuoteMissing) {
|
||||
whenInputIs("[\"]");
|
||||
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, ClosingSignleQuoteMissing) {
|
||||
whenInputIs("[\']");
|
||||
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, StringWithEscapedChars) {
|
||||
whenInputIs("[\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("1\"2\\3/4\b5\f6\n7\r8\t9");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, StringWithUnterminatedEscapeSequence) {
|
||||
whenInputIs("\"\\\0\"", 4);
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentBeforeOpeningBracket) {
|
||||
whenInputIs("/*COMMENT*/ [\"hello\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentAfterOpeningBracket) {
|
||||
whenInputIs("[/*COMMENT*/ \"hello\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentBeforeClosingBracket) {
|
||||
whenInputIs("[\"hello\"/*COMMENT*/]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentAfterClosingBracket) {
|
||||
whenInputIs("[\"hello\"]/*COMMENT*/");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentBeforeComma) {
|
||||
whenInputIs("[\"hello\"/*COMMENT*/,\"world\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CCommentAfterComma) {
|
||||
whenInputIs("[\"hello\",/*COMMENT*/ \"world\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentBeforeOpeningBracket) {
|
||||
whenInputIs("//COMMENT\n\t[\"hello\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentAfterOpeningBracket) {
|
||||
whenInputIs("[//COMMENT\n\"hello\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentBeforeClosingBracket) {
|
||||
whenInputIs("[\"hello\"//COMMENT\r\n]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentAfterClosingBracket) {
|
||||
whenInputIs("[\"hello\"]//COMMENT\n");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
firstElementMustBe("hello");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentBeforeComma) {
|
||||
whenInputIs("[\"hello\"//COMMENT\n,\"world\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, CppCommentAfterComma) {
|
||||
whenInputIs("[\"hello\",//COMMENT\n\"world\"]");
|
||||
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
firstElementMustBe("hello");
|
||||
secondElementMustBe("world");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, InvalidCppComment) {
|
||||
whenInputIs("[/COMMENT\n]");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, InvalidComment) {
|
||||
whenInputIs("[/*/\n]");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, UnfinishedCComment) {
|
||||
whenInputIs("[/*COMMENT]");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, EndsInCppComment) {
|
||||
whenInputIs("[//COMMENT");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, AfterClosingStar) {
|
||||
whenInputIs("[/*COMMENT*");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Array_Tests, DeeplyNested) {
|
||||
whenInputIs("[[[[[[[[[[[[[[[[[[[\"Not too deep\"]]]]]]]]]]]]]]]]]]]");
|
||||
parseMustSucceed();
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,182 +6,153 @@
|
||||
// If you like this project, please add a star!
|
||||
|
||||
#include <ArduinoJson.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <catch.hpp>
|
||||
|
||||
class JsonParser_Object_Test : public testing::Test {
|
||||
protected:
|
||||
void whenInputIs(const char *jsonString) {
|
||||
strcpy(_jsonString, jsonString);
|
||||
_object = &_jsonBuffer.parseObject(_jsonString);
|
||||
TEST_CASE("JsonBuffer::parseObject()") {
|
||||
DynamicJsonBuffer jb;
|
||||
|
||||
SECTION("EmptyObject") {
|
||||
JsonObject& obj = jb.parseObject("{}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 0);
|
||||
}
|
||||
|
||||
void parseMustSucceed() {
|
||||
EXPECT_TRUE(_object->success());
|
||||
SECTION("MissingOpeningBrace") {
|
||||
JsonObject& obj = jb.parseObject("}");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
}
|
||||
|
||||
void parseMustFail() {
|
||||
EXPECT_FALSE(_object->success());
|
||||
SECTION("MissingClosingBrace") {
|
||||
JsonObject& obj = jb.parseObject("{");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
}
|
||||
|
||||
void sizeMustBe(int expected) {
|
||||
EXPECT_EQ(expected, _object->size());
|
||||
SECTION("MissingColonAndValue") {
|
||||
JsonObject& obj = jb.parseObject("{\"key\"}");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
}
|
||||
|
||||
void keyMustHaveValue(const char *key, const char *expected) {
|
||||
EXPECT_STREQ(expected, (*_object)[key]);
|
||||
SECTION("MissingQuotesAndColonAndValue") {
|
||||
JsonObject& obj = jb.parseObject("{key}");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void keyMustHaveValue(const char *key, T expected) {
|
||||
EXPECT_EQ(expected, (*_object)[key].as<T>());
|
||||
SECTION("OneString") {
|
||||
JsonObject& obj = jb.parseObject("{\"key\":\"value\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
private:
|
||||
DynamicJsonBuffer _jsonBuffer;
|
||||
JsonObject *_object;
|
||||
char _jsonString[256];
|
||||
};
|
||||
SECTION("OneStringSingleQuotes") {
|
||||
JsonObject& obj = jb.parseObject("{'key':'value'}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, EmptyObject) {
|
||||
whenInputIs("{}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(0);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, MissingOpeningBrace) {
|
||||
whenInputIs("}");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, MissingClosingBrace) {
|
||||
whenInputIs("{");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, MissingColonAndValue) {
|
||||
whenInputIs("{\"key\"}");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, MissingQuotesAndColonAndValue) {
|
||||
whenInputIs("{key}");
|
||||
parseMustFail();
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneString) {
|
||||
whenInputIs("{\"key\":\"value\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringSingleQuotes) {
|
||||
whenInputIs("{'key':'value'}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringNoQuotes) {
|
||||
whenInputIs("{key:value}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringSpaceBeforeKey) {
|
||||
whenInputIs("{ \"key\":\"value\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringSpaceAfterKey) {
|
||||
whenInputIs("{\"key\" :\"value\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringSpaceBeforeValue) {
|
||||
whenInputIs("{\"key\": \"value\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, OneStringSpaceAfterValue) {
|
||||
whenInputIs("{\"key\":\"value\" }");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(1);
|
||||
keyMustHaveValue("key", "value");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoStrings) {
|
||||
whenInputIs("{\"key1\":\"value1\",\"key2\":\"value2\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", "value1");
|
||||
keyMustHaveValue("key2", "value2");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoStringsSpaceBeforeComma) {
|
||||
whenInputIs("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", "value1");
|
||||
keyMustHaveValue("key2", "value2");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoStringsSpaceAfterComma) {
|
||||
whenInputIs("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", "value1");
|
||||
keyMustHaveValue("key2", "value2");
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, EndingWithAComma) {
|
||||
whenInputIs("{\"key1\":\"value1\",}");
|
||||
parseMustFail();
|
||||
sizeMustBe(0);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoIntergers) {
|
||||
whenInputIs("{\"key1\":42,\"key2\":-42}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", 42);
|
||||
keyMustHaveValue("key2", -42);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoDoubles) {
|
||||
whenInputIs("{\"key1\":12.345,\"key2\":-7E89}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", 12.345);
|
||||
keyMustHaveValue("key2", -7E89);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoBooleans) {
|
||||
whenInputIs("{\"key1\":true,\"key2\":false}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", true);
|
||||
keyMustHaveValue("key2", false);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, TwoNulls) {
|
||||
const char *const nullstr = 0;
|
||||
|
||||
whenInputIs("{\"key1\":null,\"key2\":null}");
|
||||
parseMustSucceed();
|
||||
sizeMustBe(2);
|
||||
keyMustHaveValue("key1", nullstr);
|
||||
keyMustHaveValue("key2", nullstr);
|
||||
}
|
||||
|
||||
TEST_F(JsonParser_Object_Test, NullForKey) {
|
||||
whenInputIs("null:\"value\"}");
|
||||
parseMustFail();
|
||||
SECTION("OneStringNoQuotes") {
|
||||
JsonObject& obj = jb.parseObject("{key:value}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
SECTION("OneStringSpaceBeforeKey") {
|
||||
JsonObject& obj = jb.parseObject("{ \"key\":\"value\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
SECTION("OneStringSpaceAfterKey") {
|
||||
JsonObject& obj = jb.parseObject("{\"key\" :\"value\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
SECTION("OneStringSpaceBeforeValue") {
|
||||
JsonObject& obj = jb.parseObject("{\"key\": \"value\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
SECTION("OneStringSpaceAfterValue") {
|
||||
JsonObject& obj = jb.parseObject("{\"key\":\"value\" }");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 1);
|
||||
REQUIRE(obj["key"] == "value");
|
||||
}
|
||||
|
||||
SECTION("TwoStrings") {
|
||||
JsonObject& obj =
|
||||
jb.parseObject("{\"key1\":\"value1\",\"key2\":\"value2\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 2);
|
||||
REQUIRE(obj["key1"] == "value1");
|
||||
REQUIRE(obj["key2"] == "value2");
|
||||
}
|
||||
|
||||
SECTION("TwoStringsSpaceBeforeComma") {
|
||||
JsonObject& obj =
|
||||
jb.parseObject("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 2);
|
||||
REQUIRE(obj["key1"] == "value1");
|
||||
REQUIRE(obj["key2"] == "value2");
|
||||
}
|
||||
|
||||
SECTION("TwoStringsSpaceAfterComma") {
|
||||
JsonObject& obj =
|
||||
jb.parseObject("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 2);
|
||||
REQUIRE(obj["key1"] == "value1");
|
||||
REQUIRE(obj["key2"] == "value2");
|
||||
}
|
||||
|
||||
SECTION("EndingWithAComma") {
|
||||
JsonObject& obj = jb.parseObject("{\"key1\":\"value1\",}");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
REQUIRE(obj.size() == 0);
|
||||
}
|
||||
|
||||
SECTION("TwoIntergers") {
|
||||
JsonObject& obj = jb.parseObject("{\"key1\":42,\"key2\":-42}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 2);
|
||||
REQUIRE(obj["key1"] == 42);
|
||||
REQUIRE(obj["key2"] == -42);
|
||||
}
|
||||
|
||||
SECTION("TwoDoubles") {
|
||||
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("TwoBooleans") {
|
||||
JsonObject& obj = jb.parseObject("{\"key1\":true,\"key2\":false}");
|
||||
REQUIRE(obj.success());
|
||||
REQUIRE(obj.size() == 2);
|
||||
REQUIRE(obj["key1"] == true);
|
||||
REQUIRE(obj["key2"] == false);
|
||||
}
|
||||
|
||||
SECTION("TwoNulls") {
|
||||
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("NullForKey") {
|
||||
JsonObject& obj = jb.parseObject("null:\"value\"}");
|
||||
REQUIRE_FALSE(obj.success());
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user