From aef7e43c48c1f1af870e3558367316ba4d56ab07 Mon Sep 17 00:00:00 2001 From: Benoit Blanchon Date: Sat, 20 Dec 2014 15:42:43 +0100 Subject: [PATCH] Use DynamicJsonBuffer instead of arbitrary sized StaticJsonBuffer --- test/GbathreeBug.cpp | 58 ++++++------- test/IntegrationTests.cpp | 26 +++--- test/Issue34.cpp | 2 +- test/JsonArray_Container_Tests.cpp | 66 +++++++------- test/JsonArray_Iterator_Tests.cpp | 2 +- test/JsonArray_PrettyPrintTo_Tests.cpp | 10 +-- test/JsonObject_Container_Tests.cpp | 110 ++++++++++++------------ test/JsonObject_Iterator_Tests.cpp | 26 +++--- test/JsonObject_PrettyPrintTo_Tests.cpp | 22 ++--- test/JsonParser_Array_Tests.cpp | 2 +- test/JsonParser_Nested_Tests.cpp | 4 +- test/JsonParser_NestingLimit_Tests.cpp | 4 +- test/JsonParser_Object_Tests.cpp | 2 +- test/JsonVariant_Copy_Tests.cpp | 50 +++++------ test/JsonVariant_Storage_Tests.cpp | 14 +-- test/JsonVariant_Subscript_Tests.cpp | 58 ++++++------- 16 files changed, 228 insertions(+), 228 deletions(-) diff --git a/test/GbathreeBug.cpp b/test/GbathreeBug.cpp index e5f1173c..b1b4165b 100644 --- a/test/GbathreeBug.cpp +++ b/test/GbathreeBug.cpp @@ -10,16 +10,16 @@ class GbathreeBug : public testing::Test { public: - GbathreeBug() : object(buffer.parseObject(getJson())) {} + GbathreeBug() : _object(_buffer.parseObject(getJson())) {} protected: - char json[1024]; - StaticJsonBuffer<10000> buffer; - const JsonObject& object; + char _json[1024]; + DynamicJsonBuffer _buffer; + const JsonObject& _object; private: char* getJson() { - strcpy(json, + strcpy(_json, "{\"protocol_name\":\"fluorescence\",\"repeats\":1,\"wait\":0," "\"averages\":1,\"measurements\":3,\"meas2_light\":15,\"meas1_" "baseline\":0,\"act_light\":20,\"pulsesize\":25,\"pulsedistance\":" @@ -30,46 +30,46 @@ class GbathreeBug : public testing::Test { "\"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15," "15,15]],\"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15]," "[15,15,15,15]],\"altc\":[2,2,2,2],\"altd\":[2,2,2,2]}"); - return json; + return _json; } }; -TEST_F(GbathreeBug, Success) { EXPECT_TRUE(object.success()); } +TEST_F(GbathreeBug, Success) { EXPECT_TRUE(_object.success()); } TEST_F(GbathreeBug, ProtocolName) { - EXPECT_STREQ("fluorescence", object.at("protocol_name").asString()); + EXPECT_STREQ("fluorescence", _object.at("protocol_name").asString()); } -TEST_F(GbathreeBug, Repeats) { EXPECT_EQ(1, object["repeats"]); } +TEST_F(GbathreeBug, Repeats) { EXPECT_EQ(1, _object["repeats"]); } -TEST_F(GbathreeBug, Wait) { EXPECT_EQ(0, object["wait"]); } +TEST_F(GbathreeBug, Wait) { EXPECT_EQ(0, _object["wait"]); } -TEST_F(GbathreeBug, Measurements) { EXPECT_EQ(3, object["measurements"]); } +TEST_F(GbathreeBug, Measurements) { EXPECT_EQ(3, _object["measurements"]); } -TEST_F(GbathreeBug, Meas2_Light) { EXPECT_EQ(15, object["meas2_light"]); } +TEST_F(GbathreeBug, Meas2_Light) { EXPECT_EQ(15, _object["meas2_light"]); } -TEST_F(GbathreeBug, Meas1_Baseline) { EXPECT_EQ(0, object["meas1_baseline"]); } +TEST_F(GbathreeBug, Meas1_Baseline) { EXPECT_EQ(0, _object["meas1_baseline"]); } -TEST_F(GbathreeBug, Act_Light) { EXPECT_EQ(20, object["act_light"]); } +TEST_F(GbathreeBug, Act_Light) { EXPECT_EQ(20, _object["act_light"]); } -TEST_F(GbathreeBug, Pulsesize) { EXPECT_EQ(25, object["pulsesize"]); } +TEST_F(GbathreeBug, Pulsesize) { EXPECT_EQ(25, _object["pulsesize"]); } TEST_F(GbathreeBug, Pulsedistance) { - EXPECT_EQ(10000, object["pulsedistance"]); + EXPECT_EQ(10000, _object["pulsedistance"]); } -TEST_F(GbathreeBug, Actintensity1) { EXPECT_EQ(50, object["actintensity1"]); } +TEST_F(GbathreeBug, Actintensity1) { EXPECT_EQ(50, _object["actintensity1"]); } -TEST_F(GbathreeBug, Actintensity2) { EXPECT_EQ(255, object["actintensity2"]); } +TEST_F(GbathreeBug, Actintensity2) { EXPECT_EQ(255, _object["actintensity2"]); } -TEST_F(GbathreeBug, Measintensity) { EXPECT_EQ(255, object["measintensity"]); } +TEST_F(GbathreeBug, Measintensity) { EXPECT_EQ(255, _object["measintensity"]); } -TEST_F(GbathreeBug, Calintensity) { EXPECT_EQ(255, object["calintensity"]); } +TEST_F(GbathreeBug, Calintensity) { EXPECT_EQ(255, _object["calintensity"]); } TEST_F(GbathreeBug, Pulses) { // "pulses":[50,50,50] - JsonArray& array = object.at("pulses"); + JsonArray& array = _object.at("pulses"); EXPECT_TRUE(array.success()); EXPECT_EQ(3, array.size()); @@ -82,7 +82,7 @@ TEST_F(GbathreeBug, Pulses) { TEST_F(GbathreeBug, Act) { // "act":[2,1,2,2] - JsonArray& array = object.at("act"); + JsonArray& array = _object.at("act"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -95,7 +95,7 @@ TEST_F(GbathreeBug, Act) { TEST_F(GbathreeBug, Detectors) { // "detectors":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]] - JsonArray& array = object.at("detectors"); + JsonArray& array = _object.at("detectors"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -110,7 +110,7 @@ TEST_F(GbathreeBug, Detectors) { TEST_F(GbathreeBug, Alta) { // alta:[2,2,2,2] - JsonArray& array = object.at("alta"); + JsonArray& array = _object.at("alta"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -123,7 +123,7 @@ TEST_F(GbathreeBug, Alta) { TEST_F(GbathreeBug, Altb) { // altb:[2,2,2,2] - JsonArray& array = object.at("altb"); + JsonArray& array = _object.at("altb"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -136,7 +136,7 @@ TEST_F(GbathreeBug, Altb) { TEST_F(GbathreeBug, Measlights) { // "measlights":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]] - JsonArray& array = object.at("measlights"); + JsonArray& array = _object.at("measlights"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -152,7 +152,7 @@ TEST_F(GbathreeBug, Measlights) { TEST_F(GbathreeBug, Measlights2) { // "measlights2":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]] - JsonArray& array = object.at("measlights2"); + JsonArray& array = _object.at("measlights2"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -167,7 +167,7 @@ TEST_F(GbathreeBug, Measlights2) { TEST_F(GbathreeBug, Altc) { // altc:[2,2,2,2] - JsonArray& array = object.at("altc"); + JsonArray& array = _object.at("altc"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); @@ -180,7 +180,7 @@ TEST_F(GbathreeBug, Altc) { TEST_F(GbathreeBug, Altd) { // altd:[2,2,2,2] - JsonArray& array = object.at("altd"); + JsonArray& array = _object.at("altd"); EXPECT_TRUE(array.success()); EXPECT_EQ(4, array.size()); diff --git a/test/IntegrationTests.cpp b/test/IntegrationTests.cpp index 181819c5..582abc01 100644 --- a/test/IntegrationTests.cpp +++ b/test/IntegrationTests.cpp @@ -13,34 +13,34 @@ class IntegrationTests : public testing::TestWithParam { protected: virtual void SetUp() { _input = GetParam(); - strcpy(inputBuffer, _input); + strcpy(_inputBuffer, _input); } void parseThenPrint(char* input, char* output) { - StaticJsonBuffer<10000> json; - json.parseObject(input).printTo(output, MAX_JSON_SIZE); + DynamicJsonBuffer buffer; + buffer.parseObject(input).printTo(output, MAX_JSON_SIZE); } void parseThenPrettyPrint(char* input, char* output) { - StaticJsonBuffer<10000> json; - json.parseObject(input).prettyPrintTo(output, MAX_JSON_SIZE); + DynamicJsonBuffer buffer; + buffer.parseObject(input).prettyPrintTo(output, MAX_JSON_SIZE); } const char* _input; - char inputBuffer[MAX_JSON_SIZE]; - char outputBuffer[MAX_JSON_SIZE]; - char intermediateBuffer[MAX_JSON_SIZE]; + char _inputBuffer[MAX_JSON_SIZE]; + char _outputBuffer[MAX_JSON_SIZE]; + char _intermediateBuffer[MAX_JSON_SIZE]; }; TEST_P(IntegrationTests, ParseThenPrint) { - parseThenPrint(inputBuffer, outputBuffer); - ASSERT_STREQ(_input, outputBuffer); + parseThenPrint(_inputBuffer, _outputBuffer); + ASSERT_STREQ(_input, _outputBuffer); } TEST_P(IntegrationTests, ParseThenPrettyPrintThenParseThenPrint) { - parseThenPrettyPrint(inputBuffer, intermediateBuffer); - parseThenPrint(intermediateBuffer, outputBuffer); - ASSERT_STREQ(_input, outputBuffer); + parseThenPrettyPrint(_inputBuffer, _intermediateBuffer); + parseThenPrint(_intermediateBuffer, _outputBuffer); + ASSERT_STREQ(_input, _outputBuffer); } INSTANTIATE_TEST_CASE_P( diff --git a/test/Issue34.cpp b/test/Issue34.cpp index 68a7ebfb..5406f234 100644 --- a/test/Issue34.cpp +++ b/test/Issue34.cpp @@ -11,7 +11,7 @@ class Issue34 : public testing::Test { protected: template void test_with_value(T expected) { - StaticJsonBuffer<200> jsonBuffer; + StaticJsonBuffer jsonBuffer; JsonObject& jsonObject = jsonBuffer.createObject(); diff --git a/test/JsonArray_Container_Tests.cpp b/test/JsonArray_Container_Tests.cpp index de7cea94..52c36c93 100644 --- a/test/JsonArray_Container_Tests.cpp +++ b/test/JsonArray_Container_Tests.cpp @@ -9,7 +9,7 @@ class JsonArray_Container_Tests : public ::testing::Test { protected: - JsonArray_Container_Tests() : array(json.createArray()) {} + JsonArray_Container_Tests() : _array(_jsonBuffer.createArray()) {} template void firstMustEqual(T expected) { @@ -31,56 +31,56 @@ class JsonArray_Container_Tests : public ::testing::Test { itemMustReference(1, expected); } - void sizeMustBe(int expected) { EXPECT_EQ(expected, array.size()); } + void sizeMustBe(int expected) { EXPECT_EQ(expected, _array.size()); } - StaticJsonBuffer<256> json; - JsonArray& array; + DynamicJsonBuffer _jsonBuffer; + JsonArray& _array; private: template void itemMustEqual(int index, T expected) { - EXPECT_EQ(expected, array[index].as()); + EXPECT_EQ(expected, _array[index].as()); } template void itemMustReference(int index, const T& expected) { - EXPECT_EQ(&expected, &array[index].as()); + EXPECT_EQ(&expected, &_array[index].as()); } }; TEST_F(JsonArray_Container_Tests, SuccessIsTrue) { - EXPECT_TRUE(array.success()); + EXPECT_TRUE(_array.success()); } TEST_F(JsonArray_Container_Tests, InitialSizeIsZero) { sizeMustBe(0); } TEST_F(JsonArray_Container_Tests, Grow_WhenValuesAreAdded) { - array.add("hello"); + _array.add("hello"); sizeMustBe(1); - array.add("world"); + _array.add("world"); sizeMustBe(2); } TEST_F(JsonArray_Container_Tests, CanStoreIntegers) { - array.add(123); - array.add(456); + _array.add(123); + _array.add(456); firstMustEqual(123); secondMustEqual(456); } TEST_F(JsonArray_Container_Tests, CanStoreDoubles) { - array.add(123.45); - array.add(456.78); + _array.add(123.45); + _array.add(456.78); firstMustEqual(123.45); secondMustEqual(456.78); } TEST_F(JsonArray_Container_Tests, CanStoreBooleans) { - array.add(true); - array.add(false); + _array.add(true); + _array.add(false); firstMustEqual(true); secondMustEqual(false); @@ -90,46 +90,46 @@ TEST_F(JsonArray_Container_Tests, CanStoreStrings) { const char* firstString = "h3110"; const char* secondString = "w0r1d"; - array.add(firstString); - array.add(secondString); + _array.add(firstString); + _array.add(secondString); firstMustEqual(firstString); secondMustEqual(secondString); } TEST_F(JsonArray_Container_Tests, CanStoreNestedArrays) { - JsonArray& innerarray1 = json.createArray(); - JsonArray& innerarray2 = json.createArray(); + JsonArray& inner_array1 = _jsonBuffer.createArray(); + JsonArray& inner_array2 = _jsonBuffer.createArray(); - array.add(innerarray1); - array.add(innerarray2); + _array.add(inner_array1); + _array.add(inner_array2); - firstMustReference(innerarray1); - secondMustReference(innerarray2); + firstMustReference(inner_array1); + secondMustReference(inner_array2); } TEST_F(JsonArray_Container_Tests, CanStoreNestedObjects) { - JsonObject& innerObject1 = json.createObject(); - JsonObject& innerObject2 = json.createObject(); + JsonObject& innerObject1 = _jsonBuffer.createObject(); + JsonObject& innerObject2 = _jsonBuffer.createObject(); - array.add(innerObject1); - array.add(innerObject2); + _array.add(innerObject1); + _array.add(innerObject2); firstMustReference(innerObject1); secondMustReference(innerObject2); } TEST_F(JsonArray_Container_Tests, CanCreateNestedArrays) { - JsonArray& innerarray1 = array.createNestedArray(); - JsonArray& innerarray2 = array.createNestedArray(); + JsonArray& inner_array1 = _array.createNestedArray(); + JsonArray& inner_array2 = _array.createNestedArray(); - firstMustReference(innerarray1); - secondMustReference(innerarray2); + firstMustReference(inner_array1); + secondMustReference(inner_array2); } TEST_F(JsonArray_Container_Tests, CanCreateNestedObjects) { - JsonObject& innerObject1 = array.createNestedObject(); - JsonObject& innerObject2 = array.createNestedObject(); + JsonObject& innerObject1 = _array.createNestedObject(); + JsonObject& innerObject2 = _array.createNestedObject(); firstMustReference(innerObject1); secondMustReference(innerObject2); diff --git a/test/JsonArray_Iterator_Tests.cpp b/test/JsonArray_Iterator_Tests.cpp index 6ccc371d..8efee505 100644 --- a/test/JsonArray_Iterator_Tests.cpp +++ b/test/JsonArray_Iterator_Tests.cpp @@ -9,7 +9,7 @@ template static void run_iterator_test() { - StaticJsonBuffer<100> jsonBuffer; + StaticJsonBuffer jsonBuffer; JsonArray &array = jsonBuffer.createArray(); array.add(12); diff --git a/test/JsonArray_PrettyPrintTo_Tests.cpp b/test/JsonArray_PrettyPrintTo_Tests.cpp index e7a57238..1f4049fd 100644 --- a/test/JsonArray_PrettyPrintTo_Tests.cpp +++ b/test/JsonArray_PrettyPrintTo_Tests.cpp @@ -9,20 +9,20 @@ class JsonArray_PrettyPrintTo_Tests : public testing::Test { public: - JsonArray_PrettyPrintTo_Tests() : array(json.createArray()) {} + JsonArray_PrettyPrintTo_Tests() : array(jsonBuffer.createArray()) {} protected: - StaticJsonBuffer<200> json; + DynamicJsonBuffer jsonBuffer; JsonArray& array; void outputMustBe(const char* expected) { - size_t n = array.prettyPrintTo(buffer, sizeof(buffer)); - EXPECT_STREQ(expected, buffer); + size_t n = array.prettyPrintTo(_buffer, sizeof(_buffer)); + EXPECT_STREQ(expected, _buffer); EXPECT_EQ(strlen(expected), n); } private: - char buffer[256]; + char _buffer[256]; }; TEST_F(JsonArray_PrettyPrintTo_Tests, Empty) { outputMustBe("[]"); } diff --git a/test/JsonObject_Container_Tests.cpp b/test/JsonObject_Container_Tests.cpp index 71abeef6..07ae449a 100644 --- a/test/JsonObject_Container_Tests.cpp +++ b/test/JsonObject_Container_Tests.cpp @@ -9,118 +9,118 @@ class JsonObject_Container_Tests : public ::testing::Test { public: - JsonObject_Container_Tests() : object(json.createObject()) {} + JsonObject_Container_Tests() : _object(_jsonBuffer.createObject()) {} protected: - StaticJsonBuffer<256> json; - JsonObject& object; + DynamicJsonBuffer _jsonBuffer; + JsonObject& _object; }; TEST_F(JsonObject_Container_Tests, InitialSizeIsZero) { - EXPECT_EQ(0, object.size()); + EXPECT_EQ(0, _object.size()); } TEST_F(JsonObject_Container_Tests, Grow_WhenValuesAreAdded) { - object["hello"]; - EXPECT_EQ(1, object.size()); + _object["hello"]; + EXPECT_EQ(1, _object.size()); - object["world"]; - EXPECT_EQ(2, object.size()); + _object["world"]; + EXPECT_EQ(2, _object.size()); } TEST_F(JsonObject_Container_Tests, DoNotGrow_WhenSameValueIsAdded) { - object["hello"]; - EXPECT_EQ(1, object.size()); + _object["hello"]; + EXPECT_EQ(1, _object.size()); - object["hello"]; - EXPECT_EQ(1, object.size()); + _object["hello"]; + EXPECT_EQ(1, _object.size()); } TEST_F(JsonObject_Container_Tests, Shrink_WhenValuesAreRemoved) { - object["hello"]; - object["world"]; + _object["hello"]; + _object["world"]; - object.remove("hello"); - EXPECT_EQ(1, object.size()); + _object.remove("hello"); + EXPECT_EQ(1, _object.size()); - object.remove("world"); - EXPECT_EQ(0, object.size()); + _object.remove("world"); + EXPECT_EQ(0, _object.size()); } TEST_F(JsonObject_Container_Tests, DoNotShrink_WhenRemoveIsCalledWithAWrongKey) { - object["hello"]; - object["world"]; + _object["hello"]; + _object["world"]; - object.remove(":-P"); + _object.remove(":-P"); - EXPECT_EQ(2, object.size()); + EXPECT_EQ(2, _object.size()); } TEST_F(JsonObject_Container_Tests, CanStoreIntegers) { - object["hello"] = 123; - object["world"] = 456; + _object["hello"] = 123; + _object["world"] = 456; - EXPECT_EQ(123, object["hello"].as()); - EXPECT_EQ(456, object["world"].as()); + EXPECT_EQ(123, _object["hello"].as()); + EXPECT_EQ(456, _object["world"].as()); } TEST_F(JsonObject_Container_Tests, CanStoreDoubles) { - object["hello"] = 123.45; - object["world"] = 456.78; + _object["hello"] = 123.45; + _object["world"] = 456.78; - EXPECT_EQ(123.45, object["hello"].as()); - EXPECT_EQ(456.78, object["world"].as()); + EXPECT_EQ(123.45, _object["hello"].as()); + EXPECT_EQ(456.78, _object["world"].as()); } TEST_F(JsonObject_Container_Tests, CanStoreBooleans) { - object["hello"] = true; - object["world"] = false; + _object["hello"] = true; + _object["world"] = false; - EXPECT_TRUE(object["hello"].as()); - EXPECT_FALSE(object["world"].as()); + EXPECT_TRUE(_object["hello"].as()); + EXPECT_FALSE(_object["world"].as()); } TEST_F(JsonObject_Container_Tests, CanStoreStrings) { - object["hello"] = "h3110"; - object["world"] = "w0r1d"; + _object["hello"] = "h3110"; + _object["world"] = "w0r1d"; - EXPECT_STREQ("h3110", object["hello"].as()); - EXPECT_STREQ("w0r1d", object["world"].as()); + EXPECT_STREQ("h3110", _object["hello"].as()); + EXPECT_STREQ("w0r1d", _object["world"].as()); } TEST_F(JsonObject_Container_Tests, CanStoreInnerArrays) { - JsonArray& innerarray1 = json.createArray(); - JsonArray& innerarray2 = json.createArray(); + JsonArray& innerarray1 = _jsonBuffer.createArray(); + JsonArray& innerarray2 = _jsonBuffer.createArray(); - object["hello"] = innerarray1; - object["world"] = innerarray2; + _object["hello"] = innerarray1; + _object["world"] = innerarray2; - EXPECT_EQ(&innerarray1, &object["hello"].asArray()); - EXPECT_EQ(&innerarray2, &object["world"].asArray()); + EXPECT_EQ(&innerarray1, &_object["hello"].asArray()); + EXPECT_EQ(&innerarray2, &_object["world"].asArray()); } TEST_F(JsonObject_Container_Tests, CanStoreInnerObjects) { - JsonObject& innerObject1 = json.createObject(); - JsonObject& innerObject2 = json.createObject(); + JsonObject& innerObject1 = _jsonBuffer.createObject(); + JsonObject& innerObject2 = _jsonBuffer.createObject(); - object["hello"] = innerObject1; - object["world"] = innerObject2; + _object["hello"] = innerObject1; + _object["world"] = innerObject2; - EXPECT_EQ(&innerObject1, &object["hello"].asObject()); - EXPECT_EQ(&innerObject2, &object["world"].asObject()); + EXPECT_EQ(&innerObject1, &_object["hello"].asObject()); + EXPECT_EQ(&innerObject2, &_object["world"].asObject()); } TEST_F(JsonObject_Container_Tests, ContainsKeyReturnFalseForNonExistingKey) { - EXPECT_FALSE(object.containsKey("hello")); + EXPECT_FALSE(_object.containsKey("hello")); } TEST_F(JsonObject_Container_Tests, ContainsKeyReturnTrueForDefinedValue) { - object.add("hello", 42); - EXPECT_TRUE(object.containsKey("hello")); + _object.add("hello", 42); + EXPECT_TRUE(_object.containsKey("hello")); } TEST_F(JsonObject_Container_Tests, ContainsKeyReturnFalseForUndefinedValue) { - object.add("hello"); - EXPECT_FALSE(object.containsKey("hello")); + _object.add("hello"); + EXPECT_FALSE(_object.containsKey("hello")); } diff --git a/test/JsonObject_Iterator_Tests.cpp b/test/JsonObject_Iterator_Tests.cpp index 26fe90dd..a50d3fbe 100644 --- a/test/JsonObject_Iterator_Tests.cpp +++ b/test/JsonObject_Iterator_Tests.cpp @@ -10,39 +10,39 @@ class JsonObject_Iterator_Test : public testing::Test { public: - JsonObject_Iterator_Test() : object(_buffer.createObject()) { - object["ab"] = 12; - object["cd"] = 34; + JsonObject_Iterator_Test() : _object(_buffer.createObject()) { + _object["ab"] = 12; + _object["cd"] = 34; } protected: - StaticJsonBuffer<256> _buffer; - JsonObject& object; + StaticJsonBuffer _buffer; + JsonObject& _object; }; TEST_F(JsonObject_Iterator_Test, NonConstIterator) { - JsonObject::iterator it = object.begin(); - ASSERT_NE(object.end(), it); + JsonObject::iterator it = _object.begin(); + ASSERT_NE(_object.end(), it); EXPECT_STREQ("ab", it->key); EXPECT_EQ(12, it->value); it->key = "a.b"; it->value = 1.2; ++it; - ASSERT_NE(object.end(), it); + ASSERT_NE(_object.end(), it); EXPECT_STREQ("cd", it->key); EXPECT_EQ(34, it->value); it->key = "c.d"; it->value = 3.4; ++it; - ASSERT_EQ(object.end(), it); + ASSERT_EQ(_object.end(), it); - ASSERT_EQ(2, object.size()); - EXPECT_EQ(1.2, object["a.b"]); - EXPECT_EQ(3.4, object["c.d"]); + ASSERT_EQ(2, _object.size()); + EXPECT_EQ(1.2, _object["a.b"]); + EXPECT_EQ(3.4, _object["c.d"]); } TEST_F(JsonObject_Iterator_Test, ConstIterator) { - const JsonObject& const_object = object; + const JsonObject& const_object = _object; JsonObject::const_iterator it = const_object.begin(); ASSERT_NE(const_object.end(), it); diff --git a/test/JsonObject_PrettyPrintTo_Tests.cpp b/test/JsonObject_PrettyPrintTo_Tests.cpp index a871ffb6..ff27d7b1 100644 --- a/test/JsonObject_PrettyPrintTo_Tests.cpp +++ b/test/JsonObject_PrettyPrintTo_Tests.cpp @@ -9,14 +9,14 @@ class JsonObject_PrettyPrintTo_Tests : public testing::Test { public: - JsonObject_PrettyPrintTo_Tests() : object(json.createObject()) {} + JsonObject_PrettyPrintTo_Tests() : _object(_jsonBuffer.createObject()) {} protected: - StaticJsonBuffer<300> json; - JsonObject &object; + DynamicJsonBuffer _jsonBuffer; + JsonObject &_object; void outputMustBe(const char *expected) { - size_t n = object.prettyPrintTo(buffer, sizeof(buffer)); + size_t n = _object.prettyPrintTo(buffer, sizeof(buffer)); EXPECT_STREQ(expected, buffer); EXPECT_EQ(strlen(expected), n); } @@ -28,7 +28,7 @@ class JsonObject_PrettyPrintTo_Tests : public testing::Test { TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyObject) { outputMustBe("{}"); } TEST_F(JsonObject_PrettyPrintTo_Tests, OneMember) { - object["key"] = "value"; + _object["key"] = "value"; outputMustBe( "{\r\n" @@ -37,8 +37,8 @@ TEST_F(JsonObject_PrettyPrintTo_Tests, OneMember) { } TEST_F(JsonObject_PrettyPrintTo_Tests, TwoMembers) { - object["key1"] = "value1"; - object["key2"] = "value2"; + _object["key1"] = "value1"; + _object["key2"] = "value2"; outputMustBe( "{\r\n" @@ -48,8 +48,8 @@ TEST_F(JsonObject_PrettyPrintTo_Tests, TwoMembers) { } TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyNestedContainers) { - object.createNestedObject("key1"); - object.createNestedArray("key2"); + _object.createNestedObject("key1"); + _object.createNestedArray("key2"); outputMustBe( "{\r\n" @@ -59,10 +59,10 @@ TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyNestedContainers) { } TEST_F(JsonObject_PrettyPrintTo_Tests, NestedContainers) { - JsonObject &nested1 = object.createNestedObject("key1"); + JsonObject &nested1 = _object.createNestedObject("key1"); nested1["a"] = 1; - JsonArray &nested2 = object.createNestedArray("key2"); + JsonArray &nested2 = _object.createNestedArray("key2"); nested2.add(2); outputMustBe( diff --git a/test/JsonParser_Array_Tests.cpp b/test/JsonParser_Array_Tests.cpp index 3ea288d1..12049ec7 100644 --- a/test/JsonParser_Array_Tests.cpp +++ b/test/JsonParser_Array_Tests.cpp @@ -42,7 +42,7 @@ class JsonParser_Array_Tests : public testing::Test { EXPECT_STREQ(expected, _array->at(index).as()); } - StaticJsonBuffer<256> _jsonBuffer; + DynamicJsonBuffer _jsonBuffer; JsonArray *_array; char _jsonString[256]; }; diff --git a/test/JsonParser_Nested_Tests.cpp b/test/JsonParser_Nested_Tests.cpp index af125127..95f2d13e 100644 --- a/test/JsonParser_Nested_Tests.cpp +++ b/test/JsonParser_Nested_Tests.cpp @@ -8,7 +8,7 @@ #include TEST(JsonParser_Nested_Tests, ArrayNestedInObject) { - StaticJsonBuffer<256> jsonBuffer; + DynamicJsonBuffer jsonBuffer; char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } "; JsonObject &object = jsonBuffer.parseObject(jsonString); @@ -31,7 +31,7 @@ TEST(JsonParser_Nested_Tests, ArrayNestedInObject) { } TEST(JsonParser_Nested_Tests, ObjectNestedInArray) { - StaticJsonBuffer<256> jsonBuffer; + DynamicJsonBuffer jsonBuffer; char jsonString[] = " [ { \"a\" : 1 , \"b\" : 2 } , { \"c\" : 3 , \"d\" : 4 } ] "; diff --git a/test/JsonParser_NestingLimit_Tests.cpp b/test/JsonParser_NestingLimit_Tests.cpp index 04278efb..943d8bd1 100644 --- a/test/JsonParser_NestingLimit_Tests.cpp +++ b/test/JsonParser_NestingLimit_Tests.cpp @@ -31,14 +31,14 @@ class JsonParser_NestingLimit_Tests : public testing::Test { private: bool tryParseArray(const char *json) { - StaticJsonBuffer<256> buffer; + DynamicJsonBuffer buffer; char s[256]; strcpy(s, json); return buffer.parseArray(s, _nestingLimit).success(); } bool tryParseObject(const char *json) { - StaticJsonBuffer<256> buffer; + DynamicJsonBuffer buffer; char s[256]; strcpy(s, json); return buffer.parseObject(s, _nestingLimit).success(); diff --git a/test/JsonParser_Object_Tests.cpp b/test/JsonParser_Object_Tests.cpp index 148d496a..ef32f92c 100644 --- a/test/JsonParser_Object_Tests.cpp +++ b/test/JsonParser_Object_Tests.cpp @@ -30,7 +30,7 @@ class JsonParser_Object_Test : public testing::Test { } private: - StaticJsonBuffer<256> _jsonBuffer; + DynamicJsonBuffer _jsonBuffer; JsonObject *_object; char _jsonString[256]; }; diff --git a/test/JsonVariant_Copy_Tests.cpp b/test/JsonVariant_Copy_Tests.cpp index be5364ab..e4460590 100644 --- a/test/JsonVariant_Copy_Tests.cpp +++ b/test/JsonVariant_Copy_Tests.cpp @@ -9,59 +9,59 @@ class JsonVariant_Copy_Tests : public ::testing::Test { protected: - StaticJsonBuffer<200> json; - JsonVariant variant1; - JsonVariant variant2; + DynamicJsonBuffer _jsonBuffer; + JsonVariant _variant1; + JsonVariant _variant2; }; TEST_F(JsonVariant_Copy_Tests, IntegersAreCopiedByValue) { - variant1 = 123; - variant2 = variant1; - variant1 = 456; + _variant1 = 123; + _variant2 = _variant1; + _variant1 = 456; - EXPECT_EQ(123, variant2.as()); + EXPECT_EQ(123, _variant2.as()); } TEST_F(JsonVariant_Copy_Tests, DoublesAreCopiedByValue) { - variant1 = 123.45; - variant2 = variant1; - variant1 = 456.78; + _variant1 = 123.45; + _variant2 = _variant1; + _variant1 = 456.78; - EXPECT_EQ(123.45, variant2.as()); + EXPECT_EQ(123.45, _variant2.as()); } TEST_F(JsonVariant_Copy_Tests, BooleansAreCopiedByValue) { - variant1 = true; - variant2 = variant1; - variant1 = false; + _variant1 = true; + _variant2 = _variant1; + _variant1 = false; - EXPECT_TRUE(variant2.as()); + EXPECT_TRUE(_variant2.as()); } TEST_F(JsonVariant_Copy_Tests, StringsAreCopiedByValue) { - variant1 = "hello"; - variant2 = variant1; - variant1 = "world"; + _variant1 = "hello"; + _variant2 = _variant1; + _variant1 = "world"; - EXPECT_STREQ("hello", variant2.as()); + EXPECT_STREQ("hello", _variant2.as()); } TEST_F(JsonVariant_Copy_Tests, ObjectsAreCopiedByReference) { - JsonObject &object = json.createObject(); + JsonObject &object = _jsonBuffer.createObject(); - variant1 = object; + _variant1 = object; object["hello"] = "world"; - EXPECT_EQ(1, variant1.asObject().size()); + EXPECT_EQ(1, _variant1.asObject().size()); } TEST_F(JsonVariant_Copy_Tests, ArraysAreCopiedByReference) { - JsonArray &array = json.createArray(); + JsonArray &array = _jsonBuffer.createArray(); - variant1 = array; + _variant1 = array; array.add("world"); - EXPECT_EQ(1, variant1.asArray().size()); + EXPECT_EQ(1, _variant1.asArray().size()); } diff --git a/test/JsonVariant_Storage_Tests.cpp b/test/JsonVariant_Storage_Tests.cpp index 0c7b6e0e..128c324b 100644 --- a/test/JsonVariant_Storage_Tests.cpp +++ b/test/JsonVariant_Storage_Tests.cpp @@ -11,18 +11,18 @@ class JsonVariant_Storage_Tests : public ::testing::Test { protected: template void testValue(T expected) { - actual.set(expected); - EXPECT_EQ(expected, actual.as()); + _actual.set(expected); + EXPECT_EQ(expected, _actual.as()); } template void testReference(T &expected) { - actual.set(expected); - EXPECT_EQ(expected, actual.as()); + _actual.set(expected); + EXPECT_EQ(expected, _actual.as()); } private: - JsonVariant actual; + JsonVariant _actual; }; TEST_F(JsonVariant_Storage_Tests, Double) { testValue(123.45); } @@ -41,8 +41,8 @@ TEST_F(JsonVariant_Storage_Tests, ULong) { testValue(123UL); } TEST_F(JsonVariant_Storage_Tests, UShort) { testValue(123); } TEST_F(JsonVariant_Storage_Tests, CanStoreObject) { - StaticJsonBuffer<200> json; - JsonObject &object = json.createObject(); + DynamicJsonBuffer jsonBuffer; + JsonObject &object = jsonBuffer.createObject(); testReference(object); } diff --git a/test/JsonVariant_Subscript_Tests.cpp b/test/JsonVariant_Subscript_Tests.cpp index 46edbecf..88dbd9fe 100644 --- a/test/JsonVariant_Subscript_Tests.cpp +++ b/test/JsonVariant_Subscript_Tests.cpp @@ -9,56 +9,56 @@ class JsonVariant_Subscript_Tests : public ::testing::Test { protected: - StaticJsonBuffer<200> buffer; - JsonVariant variant; + DynamicJsonBuffer _jsonBuffer; + JsonVariant _variant; }; TEST_F(JsonVariant_Subscript_Tests, Array) { - JsonArray &array = buffer.createArray(); + JsonArray &array = _jsonBuffer.createArray(); array.add("element at index 0"); array.add("element at index 1"); - variant = array; + _variant = array; - EXPECT_EQ(2, variant.size()); - EXPECT_STREQ("element at index 0", variant[0].asString()); - EXPECT_STREQ("element at index 1", variant[1].asString()); - EXPECT_FALSE(variant[-1].success()); - EXPECT_FALSE(variant[3].success()); - EXPECT_FALSE(variant["0"].success()); + EXPECT_EQ(2, _variant.size()); + EXPECT_STREQ("element at index 0", _variant[0].asString()); + EXPECT_STREQ("element at index 1", _variant[1].asString()); + EXPECT_FALSE(_variant[-1].success()); + EXPECT_FALSE(_variant[3].success()); + EXPECT_FALSE(_variant["0"].success()); } TEST_F(JsonVariant_Subscript_Tests, Object) { - JsonObject &object = buffer.createObject(); + JsonObject &object = _jsonBuffer.createObject(); object["a"] = "element at key \"a\""; object["b"] = "element at key \"b\""; - variant = object; + _variant = object; - EXPECT_EQ(2, variant.size()); - EXPECT_STREQ("element at key \"a\"", variant["a"].asString()); - EXPECT_STREQ("element at key \"b\"", variant["b"].asString()); - EXPECT_FALSE(variant["c"].success()); - EXPECT_FALSE(variant[0].success()); + EXPECT_EQ(2, _variant.size()); + EXPECT_STREQ("element at key \"a\"", _variant["a"].asString()); + EXPECT_STREQ("element at key \"b\"", _variant["b"].asString()); + EXPECT_FALSE(_variant["c"].success()); + EXPECT_FALSE(_variant[0].success()); } TEST_F(JsonVariant_Subscript_Tests, Undefined) { - variant = JsonVariant(); - EXPECT_EQ(0, variant.size()); - EXPECT_FALSE(variant["0"].success()); - EXPECT_FALSE(variant[0].success()); + _variant = JsonVariant(); + EXPECT_EQ(0, _variant.size()); + EXPECT_FALSE(_variant["0"].success()); + EXPECT_FALSE(_variant[0].success()); } TEST_F(JsonVariant_Subscript_Tests, Invalid) { - variant = JsonVariant::invalid(); - EXPECT_EQ(0, variant.size()); - EXPECT_FALSE(variant["0"].success()); - EXPECT_FALSE(variant[0].success()); + _variant = JsonVariant::invalid(); + EXPECT_EQ(0, _variant.size()); + EXPECT_FALSE(_variant["0"].success()); + EXPECT_FALSE(_variant[0].success()); } TEST_F(JsonVariant_Subscript_Tests, String) { - variant = "hello world"; - EXPECT_EQ(0, variant.size()); - EXPECT_FALSE(variant["0"].success()); - EXPECT_FALSE(variant[0].success()); + _variant = "hello world"; + EXPECT_EQ(0, _variant.size()); + EXPECT_FALSE(_variant["0"].success()); + EXPECT_FALSE(_variant[0].success()); }