From 09f6d059a745a4744f0f7176c9885bf8f6dac0d4 Mon Sep 17 00:00:00 2001 From: Benoit Blanchon Date: Tue, 4 Nov 2014 09:51:25 +0100 Subject: [PATCH] Renamed JsonValue to JsonVariant --- .../ArduinoJson/Internals/JsonArrayNode.hpp | 4 +- include/ArduinoJson/Internals/JsonParser.hpp | 8 +-- ...alueContent.hpp => JsonVariantContent.hpp} | 2 +- ...{JsonValueType.hpp => JsonVariantType.hpp} | 2 +- include/ArduinoJson/JsonArray.hpp | 2 +- .../ArduinoJson/JsonArrayConstIterator.hpp | 4 +- include/ArduinoJson/JsonArrayIterator.hpp | 4 +- include/ArduinoJson/JsonBuffer.hpp | 2 +- include/ArduinoJson/JsonObject.hpp | 10 ++-- include/ArduinoJson/JsonPair.hpp | 4 +- .../{JsonValue.hpp => JsonVariant.hpp} | 52 +++++++++---------- src/Internals/JsonParser.cpp | 18 +++---- src/JsonArray.cpp | 8 +-- src/JsonBuffer.cpp | 2 +- src/JsonObject.cpp | 14 ++--- src/{JsonValue.cpp => JsonVariant.cpp} | 36 ++++++------- test/Issue10.cpp | 2 +- test/JsonArray_Container_Tests.cpp | 2 +- test/JsonArray_PrettyPrintTo_Tests.cpp | 2 +- test/JsonObject_Container_Tests.cpp | 2 +- test/JsonObject_PrettyPrintTo_Tests.cpp | 2 +- test/JsonObject_PrintTo_Tests.cpp | 4 +- test/JsonParser_Array_Tests.cpp | 2 +- test/JsonParser_Object_Tests.cpp | 2 +- test/JsonValue_Storage_Tests.cpp | 52 ------------------- ...s.cpp => JsonVariant_Comparison_Tests.cpp} | 26 +++++----- ...y_Tests.cpp => JsonVariant_Copy_Tests.cpp} | 20 +++---- test/JsonVariant_Storage_Tests.cpp | 52 +++++++++++++++++++ test/Printers.cpp | 4 +- test/Printers.hpp | 4 +- test/StaticJsonBufferTests.cpp | 2 +- 31 files changed, 175 insertions(+), 175 deletions(-) rename include/ArduinoJson/Internals/{JsonValueContent.hpp => JsonVariantContent.hpp} (92%) rename include/ArduinoJson/Internals/{JsonValueType.hpp => JsonVariantType.hpp} (94%) rename include/ArduinoJson/{JsonValue.hpp => JsonVariant.hpp} (69%) rename src/{JsonValue.cpp => JsonVariant.cpp} (69%) delete mode 100644 test/JsonValue_Storage_Tests.cpp rename test/{JsonValue_Comparison_Tests.cpp => JsonVariant_Comparison_Tests.cpp} (75%) rename test/{JsonValue_Copy_Tests.cpp => JsonVariant_Copy_Tests.cpp} (68%) create mode 100644 test/JsonVariant_Storage_Tests.cpp diff --git a/include/ArduinoJson/Internals/JsonArrayNode.hpp b/include/ArduinoJson/Internals/JsonArrayNode.hpp index c6404475..9beff3c2 100644 --- a/include/ArduinoJson/Internals/JsonArrayNode.hpp +++ b/include/ArduinoJson/Internals/JsonArrayNode.hpp @@ -6,7 +6,7 @@ #pragma once -#include "../JsonValue.hpp" +#include "../JsonVariant.hpp" namespace ArduinoJson { namespace Internals { @@ -15,7 +15,7 @@ struct JsonArrayNode { JsonArrayNode() : next(NULL) {} JsonArrayNode* next; - JsonValue value; + JsonVariant value; }; } } diff --git a/include/ArduinoJson/Internals/JsonParser.hpp b/include/ArduinoJson/Internals/JsonParser.hpp index be21b385..5fc1a58f 100644 --- a/include/ArduinoJson/Internals/JsonParser.hpp +++ b/include/ArduinoJson/Internals/JsonParser.hpp @@ -25,10 +25,10 @@ class JsonParser { bool skip(const char *wordToSkip); void skipSpaces(); - void parseAnythingTo(JsonValue &destination); - inline void parseBooleanTo(JsonValue &destination); - inline void parseNullTo(JsonValue &destination); - inline void parseNumberTo(JsonValue &destination); + void parseAnythingTo(JsonVariant &destination); + inline void parseBooleanTo(JsonVariant &destination); + inline void parseNullTo(JsonVariant &destination); + inline void parseNumberTo(JsonVariant &destination); inline const char *parseString(); JsonBuffer *_buffer; diff --git a/include/ArduinoJson/Internals/JsonValueContent.hpp b/include/ArduinoJson/Internals/JsonVariantContent.hpp similarity index 92% rename from include/ArduinoJson/Internals/JsonValueContent.hpp rename to include/ArduinoJson/Internals/JsonVariantContent.hpp index af9b7c08..d6966206 100644 --- a/include/ArduinoJson/Internals/JsonValueContent.hpp +++ b/include/ArduinoJson/Internals/JsonVariantContent.hpp @@ -13,7 +13,7 @@ class JsonObject; namespace Internals { -union JsonValueContent { +union JsonVariantContent { bool asBoolean; double asDouble; long asLong; diff --git a/include/ArduinoJson/Internals/JsonValueType.hpp b/include/ArduinoJson/Internals/JsonVariantType.hpp similarity index 94% rename from include/ArduinoJson/Internals/JsonValueType.hpp rename to include/ArduinoJson/Internals/JsonVariantType.hpp index 5d9574cd..3bf11ad8 100644 --- a/include/ArduinoJson/Internals/JsonValueType.hpp +++ b/include/ArduinoJson/Internals/JsonVariantType.hpp @@ -9,7 +9,7 @@ namespace ArduinoJson { namespace Internals { -enum JsonValueType { +enum JsonVariantType { JSON_UNDEFINED, JSON_INVALID, JSON_ARRAY, diff --git a/include/ArduinoJson/JsonArray.hpp b/include/ArduinoJson/JsonArray.hpp index d2d596a1..dce39ac0 100644 --- a/include/ArduinoJson/JsonArray.hpp +++ b/include/ArduinoJson/JsonArray.hpp @@ -24,7 +24,7 @@ class JsonArray : public JsonPrintable, friend class JsonBuffer; public: - typedef JsonValue value_type; + typedef JsonVariant value_type; typedef JsonArrayIterator iterator; typedef JsonArrayConstIterator const_iterator; diff --git a/include/ArduinoJson/JsonArrayConstIterator.hpp b/include/ArduinoJson/JsonArrayConstIterator.hpp index 863bc83e..228db139 100644 --- a/include/ArduinoJson/JsonArrayConstIterator.hpp +++ b/include/ArduinoJson/JsonArrayConstIterator.hpp @@ -15,8 +15,8 @@ class JsonArrayConstIterator { explicit JsonArrayConstIterator(Internals::JsonArrayNode *node) : _node(node) {} - const JsonValue &operator*() const { return _node->value; } - const JsonValue *operator->() { return &_node->value; } + const JsonVariant &operator*() const { return _node->value; } + const JsonVariant *operator->() { return &_node->value; } bool operator==(const JsonArrayConstIterator &other) const { return _node == other._node; diff --git a/include/ArduinoJson/JsonArrayIterator.hpp b/include/ArduinoJson/JsonArrayIterator.hpp index d043b76e..f77f39a8 100644 --- a/include/ArduinoJson/JsonArrayIterator.hpp +++ b/include/ArduinoJson/JsonArrayIterator.hpp @@ -14,8 +14,8 @@ class JsonArrayIterator { public: explicit JsonArrayIterator(Internals::JsonArrayNode *node) : _node(node) {} - JsonValue &operator*() const { return _node->value; } - JsonValue *operator->() { return &_node->value; } + JsonVariant &operator*() const { return _node->value; } + JsonVariant *operator->() { return &_node->value; } bool operator==(const JsonArrayIterator &other) const { return _node == other._node; diff --git a/include/ArduinoJson/JsonBuffer.hpp b/include/ArduinoJson/JsonBuffer.hpp index 65ed2b72..fffd7804 100644 --- a/include/ArduinoJson/JsonBuffer.hpp +++ b/include/ArduinoJson/JsonBuffer.hpp @@ -6,7 +6,7 @@ #pragma once -#include "JsonValue.hpp" +#include "JsonVariant.hpp" namespace ArduinoJson { class JsonArray; diff --git a/include/ArduinoJson/JsonObject.hpp b/include/ArduinoJson/JsonObject.hpp index af75a044..a131dabf 100644 --- a/include/ArduinoJson/JsonObject.hpp +++ b/include/ArduinoJson/JsonObject.hpp @@ -33,10 +33,10 @@ class JsonObject : public JsonPrintable, bool success() const { return _buffer != NULL; } int size() const; - JsonValue &at(key_type key); - const JsonValue &at(key_type key) const; - JsonValue &operator[](key_type key); - const JsonValue &operator[](key_type key) const { return at(key); } + JsonVariant &at(key_type key); + const JsonVariant &at(key_type key) const; + JsonVariant &operator[](key_type key); + const JsonVariant &operator[](key_type key) const { return at(key); } void remove(key_type key); @@ -65,7 +65,7 @@ class JsonObject : public JsonPrintable, // constructor is private, instance must be created via JsonBuffer JsonObject(JsonBuffer *buffer) : _buffer(buffer), _firstNode(NULL) {} - JsonValue &add(key_type key) { return (*this)[key]; } + JsonVariant &add(key_type key) { return (*this)[key]; } Internals::JsonObjectNode *createNode(key_type key); void addNode(Internals::JsonObjectNode *nodeToAdd); void removeNode(Internals::JsonObjectNode *nodeToRemove); diff --git a/include/ArduinoJson/JsonPair.hpp b/include/ArduinoJson/JsonPair.hpp index 670bdef9..143be11d 100644 --- a/include/ArduinoJson/JsonPair.hpp +++ b/include/ArduinoJson/JsonPair.hpp @@ -6,7 +6,7 @@ #pragma once -#include "JsonValue.hpp" +#include "JsonVariant.hpp" namespace ArduinoJson { @@ -14,6 +14,6 @@ struct JsonPair { JsonPair(const char* k) : key(k) {} const char* key; - JsonValue value; + JsonVariant value; }; } diff --git a/include/ArduinoJson/JsonValue.hpp b/include/ArduinoJson/JsonVariant.hpp similarity index 69% rename from include/ArduinoJson/JsonValue.hpp rename to include/ArduinoJson/JsonVariant.hpp index 8cfe4d6d..b37c79bf 100644 --- a/include/ArduinoJson/JsonValue.hpp +++ b/include/ArduinoJson/JsonVariant.hpp @@ -9,8 +9,8 @@ #include #include // for uint8_t -#include "Internals/JsonValueContent.hpp" -#include "Internals/JsonValueType.hpp" +#include "Internals/JsonVariantContent.hpp" +#include "Internals/JsonVariantType.hpp" namespace ArduinoJson { @@ -21,9 +21,9 @@ namespace Internals { class JsonWriter; } -class JsonValue { +class JsonVariant { public: - JsonValue() : _type(Internals::JSON_UNDEFINED) {} + JsonVariant() : _type(Internals::JSON_UNDEFINED) {} void set(bool value); void set(double value, uint8_t decimals = 2); @@ -40,17 +40,17 @@ class JsonValue { void set(JsonObject &object); template - JsonValue &operator=(T value) { + JsonVariant &operator=(T value) { set(value); return *this; } - JsonValue &operator=(JsonArray &array) { + JsonVariant &operator=(JsonArray &array) { set(array); return *this; } - JsonValue &operator=(JsonObject &object) { + JsonVariant &operator=(JsonObject &object) { set(object); return *this; } @@ -84,7 +84,7 @@ class JsonValue { return false; } - static JsonValue &invalid() { return _invalid; } + static JsonVariant &invalid() { return _invalid; } bool success() { return _type != Internals::JSON_INVALID; } @@ -92,80 +92,80 @@ class JsonValue { void writeTo(T &writer) const; private: - JsonValue(Internals::JsonValueType type) : _type(type) {} + JsonVariant(Internals::JsonVariantType type) : _type(type) {} - Internals::JsonValueType _type; - Internals::JsonValueContent _content; - static JsonValue _invalid; + Internals::JsonVariantType _type; + Internals::JsonVariantContent _content; + static JsonVariant _invalid; }; template <> -inline bool JsonValue::is() const { +inline bool JsonVariant::is() const { return _type == Internals::JSON_LONG; } template <> -inline bool JsonValue::is() const { +inline bool JsonVariant::is() const { return _type >= Internals::JSON_DOUBLE_0_DECIMALS; } template -inline bool operator==(const JsonValue &left, T right) { +inline bool operator==(const JsonVariant &left, T right) { return left.as() == right; } template -inline bool operator==(T left, const JsonValue &right) { +inline bool operator==(T left, const JsonVariant &right) { return left == right.as(); } template -inline bool operator!=(const JsonValue &left, T right) { +inline bool operator!=(const JsonVariant &left, T right) { return left.as() != right; } template -inline bool operator!=(T left, const JsonValue &right) { +inline bool operator!=(T left, const JsonVariant &right) { return left != right.as(); } template -inline bool operator<=(const JsonValue &left, T right) { +inline bool operator<=(const JsonVariant &left, T right) { return left.as() <= right; } template -inline bool operator<=(T left, const JsonValue &right) { +inline bool operator<=(T left, const JsonVariant &right) { return left <= right.as(); } template -inline bool operator>=(const JsonValue &left, T right) { +inline bool operator>=(const JsonVariant &left, T right) { return left.as() >= right; } template -inline bool operator>=(T left, const JsonValue &right) { +inline bool operator>=(T left, const JsonVariant &right) { return left >= right.as(); } template -inline bool operator<(const JsonValue &left, T right) { +inline bool operator<(const JsonVariant &left, T right) { return left.as() < right; } template -inline bool operator<(T left, const JsonValue &right) { +inline bool operator<(T left, const JsonVariant &right) { return left < right.as(); } template -inline bool operator>(const JsonValue &left, T right) { +inline bool operator>(const JsonVariant &left, T right) { return left.as() > right; } template -inline bool operator>(T left, const JsonValue &right) { +inline bool operator>(T left, const JsonVariant &right) { return left > right.as(); } } diff --git a/src/Internals/JsonParser.cpp b/src/Internals/JsonParser.cpp index a3a427b7..61066656 100644 --- a/src/Internals/JsonParser.cpp +++ b/src/Internals/JsonParser.cpp @@ -11,7 +11,7 @@ #include "../../include/ArduinoJson/JsonArray.hpp" #include "../../include/ArduinoJson/JsonBuffer.hpp" -#include "../../include/ArduinoJson/JsonValue.hpp" +#include "../../include/ArduinoJson/JsonVariant.hpp" #include "../../include/ArduinoJson/JsonObject.hpp" #include "../../include/ArduinoJson/Internals/QuotedString.hpp" @@ -39,7 +39,7 @@ bool JsonParser::skip(const char *wordToSkip) { return *charToSkip == '\0'; } -void JsonParser::parseAnythingTo(JsonValue &destination) { +void JsonParser::parseAnythingTo(JsonVariant &destination) { skipSpaces(); switch (*_ptr) { @@ -91,7 +91,7 @@ JsonArray &JsonParser::parseArray() { if (skip(']')) return array; // empty array for (;;) { - JsonValue &child = array.add(); + JsonVariant &child = array.add(); parseAnythingTo(child); if (!child.success()) return JsonArray::invalid(); // child parsing failed @@ -102,16 +102,16 @@ JsonArray &JsonParser::parseArray() { } } -void JsonParser::parseBooleanTo(JsonValue &destination) { +void JsonParser::parseBooleanTo(JsonVariant &destination) { bool value = *_ptr == 't'; if (skip(value ? "true" : "false")) destination = value; else - destination = JsonValue::invalid(); + destination = JsonVariant::invalid(); } -void JsonParser::parseNumberTo(JsonValue &destination) { +void JsonParser::parseNumberTo(JsonVariant &destination) { char *endOfLong; long longValue = strtol(_ptr, &endOfLong, 10); @@ -126,11 +126,11 @@ void JsonParser::parseNumberTo(JsonValue &destination) { } } -void JsonParser::parseNullTo(JsonValue &destination) { +void JsonParser::parseNullTo(JsonVariant &destination) { if (skip("null")) destination = static_cast(NULL); else - destination = JsonValue::invalid(); + destination = JsonVariant::invalid(); } JsonObject &JsonParser::parseObject() { @@ -148,7 +148,7 @@ JsonObject &JsonParser::parseObject() { if (!skip(':')) break; // colon is missing - JsonValue &value = object[key]; + JsonVariant &value = object[key]; parseAnythingTo(value); if (!value.success()) break; // value parsing failed diff --git a/src/JsonArray.cpp b/src/JsonArray.cpp index 9ec7da0d..bbb97644 100644 --- a/src/JsonArray.cpp +++ b/src/JsonArray.cpp @@ -22,15 +22,15 @@ int JsonArray::size() const { return nodeCount; } -JsonValue &JsonArray::at(int index) const { +JsonVariant &JsonArray::at(int index) const { JsonArrayNode *node = _firstNode; while (node && index--) node = node->next; - return node ? node->value : JsonValue::invalid(); + return node ? node->value : JsonVariant::invalid(); } -JsonValue &JsonArray::add() { +JsonVariant &JsonArray::add() { JsonArrayNode *node = createNode(); - if (!node) return JsonValue::invalid(); + if (!node) return JsonVariant::invalid(); addNode(node); diff --git a/src/JsonBuffer.cpp b/src/JsonBuffer.cpp index b88371c5..0e9551fc 100644 --- a/src/JsonBuffer.cpp +++ b/src/JsonBuffer.cpp @@ -8,7 +8,7 @@ #include "../include/ArduinoJson/JsonArray.hpp" #include "../include/ArduinoJson/JsonObject.hpp" -#include "../include/ArduinoJson/JsonValue.hpp" +#include "../include/ArduinoJson/JsonVariant.hpp" #include "../include/ArduinoJson/Internals/PlacementNew.hpp" #include "../include/ArduinoJson/Internals/JsonParser.hpp" diff --git a/src/JsonObject.cpp b/src/JsonObject.cpp index 37674e82..8d91d46a 100644 --- a/src/JsonObject.cpp +++ b/src/JsonObject.cpp @@ -10,7 +10,7 @@ #include "../include/ArduinoJson/JsonBuffer.hpp" #include "../include/ArduinoJson/JsonArray.hpp" -#include "../include/ArduinoJson/JsonValue.hpp" +#include "../include/ArduinoJson/JsonVariant.hpp" #include "../include/ArduinoJson/Internals/PrettyJsonWriter.hpp" #include "../include/ArduinoJson/Internals/StringBuilder.hpp" #include "../include/ArduinoJson/Internals/PlacementNew.hpp" @@ -26,19 +26,19 @@ int JsonObject::size() const { return nodeCount; } -JsonValue &JsonObject::at(const char *key) { +JsonVariant &JsonObject::at(const char *key) { JsonObjectNode *node = getNodeAt(key); - return node ? node->pair.value : JsonValue::invalid(); + return node ? node->pair.value : JsonVariant::invalid(); } -const JsonValue &JsonObject::at(const char *key) const { +const JsonVariant &JsonObject::at(const char *key) const { JsonObjectNode *node = getNodeAt(key); - return node ? node->pair.value : JsonValue::invalid(); + return node ? node->pair.value : JsonVariant::invalid(); } -JsonValue &JsonObject::operator[](const char *key) { +JsonVariant &JsonObject::operator[](const char *key) { JsonObjectNode *node = getOrCreateNodeAt(key); - return node ? node->pair.value : JsonValue::invalid(); + return node ? node->pair.value : JsonVariant::invalid(); } void JsonObject::remove(char const *key) { removeNode(getNodeAt(key)); } diff --git a/src/JsonValue.cpp b/src/JsonVariant.cpp similarity index 69% rename from src/JsonValue.cpp rename to src/JsonVariant.cpp index 9baa8b17..6c0b4adc 100644 --- a/src/JsonValue.cpp +++ b/src/JsonVariant.cpp @@ -4,7 +4,7 @@ // Arduino JSON library // https://github.com/bblanchon/ArduinoJson -#include "../include/ArduinoJson/JsonValue.hpp" +#include "../include/ArduinoJson/JsonVariant.hpp" #include "../include/ArduinoJson/JsonArray.hpp" #include "../include/ArduinoJson/JsonObject.hpp" #include "../include/ArduinoJson/Internals/PrettyJsonWriter.hpp" @@ -12,70 +12,70 @@ using namespace ArduinoJson; using namespace ArduinoJson::Internals; -JsonValue JsonValue::_invalid(JSON_INVALID); +JsonVariant JsonVariant::_invalid(JSON_INVALID); -JsonValue::operator JsonArray &() const { +JsonVariant::operator JsonArray &() const { return _type == JSON_ARRAY ? *_content.asArray : JsonArray::invalid(); } -JsonValue::operator JsonObject &() const { +JsonVariant::operator JsonObject &() const { return _type == JSON_OBJECT ? *_content.asObject : JsonObject::invalid(); } -JsonValue::operator bool() const { +JsonVariant::operator bool() const { return _type == JSON_BOOLEAN ? _content.asBoolean : false; } -JsonValue::operator const char *() const { +JsonVariant::operator const char *() const { return _type == JSON_STRING ? _content.asString : NULL; } -JsonValue::operator double() const { +JsonVariant::operator double() const { return _type >= JSON_DOUBLE_0_DECIMALS ? _content.asDouble : 0; } -JsonValue::operator long() const { +JsonVariant::operator long() const { return _type == JSON_LONG ? _content.asLong : 0; } -void JsonValue::set(bool value) { +void JsonVariant::set(bool value) { if (_type == JSON_INVALID) return; _type = Internals::JSON_BOOLEAN; _content.asBoolean = value; } -void JsonValue::set(const char *value) { +void JsonVariant::set(const char *value) { if (_type == JSON_INVALID) return; _type = JSON_STRING; _content.asString = value; } -void JsonValue::set(double value, uint8_t decimals) { +void JsonVariant::set(double value, uint8_t decimals) { if (_type == JSON_INVALID) return; - _type = static_cast(JSON_DOUBLE_0_DECIMALS + decimals); + _type = static_cast(JSON_DOUBLE_0_DECIMALS + decimals); _content.asDouble = value; } -void JsonValue::set(long value) { +void JsonVariant::set(long value) { if (_type == JSON_INVALID) return; _type = JSON_LONG; _content.asLong = value; } -void JsonValue::set(JsonArray &array) { +void JsonVariant::set(JsonArray &array) { if (_type == JSON_INVALID) return; _type = JSON_ARRAY; _content.asArray = &array; } -void JsonValue::set(JsonObject &object) { +void JsonVariant::set(JsonObject &object) { if (_type == JSON_INVALID) return; _type = JSON_OBJECT; _content.asObject = &object; } template -void JsonValue::writeTo(T &writer) const { +void JsonVariant::writeTo(T &writer) const { switch (_type) { case JSON_ARRAY: _content.asArray->writeTo(writer); @@ -103,5 +103,5 @@ void JsonValue::writeTo(T &writer) const { } } -template void JsonValue::writeTo(JsonWriter &) const; -template void JsonValue::writeTo(PrettyJsonWriter &) const; +template void JsonVariant::writeTo(JsonWriter &) const; +template void JsonVariant::writeTo(PrettyJsonWriter &) const; diff --git a/test/Issue10.cpp b/test/Issue10.cpp index b1a0c481..1b2d40f8 100644 --- a/test/Issue10.cpp +++ b/test/Issue10.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include using namespace ArduinoJson; diff --git a/test/JsonArray_Container_Tests.cpp b/test/JsonArray_Container_Tests.cpp index 7e58ffcc..8190c969 100644 --- a/test/JsonArray_Container_Tests.cpp +++ b/test/JsonArray_Container_Tests.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include #include diff --git a/test/JsonArray_PrettyPrintTo_Tests.cpp b/test/JsonArray_PrettyPrintTo_Tests.cpp index bec01863..78c168bf 100644 --- a/test/JsonArray_PrettyPrintTo_Tests.cpp +++ b/test/JsonArray_PrettyPrintTo_Tests.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include using namespace ArduinoJson; diff --git a/test/JsonObject_Container_Tests.cpp b/test/JsonObject_Container_Tests.cpp index cc53a35c..dead46e9 100644 --- a/test/JsonObject_Container_Tests.cpp +++ b/test/JsonObject_Container_Tests.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include using namespace ArduinoJson; diff --git a/test/JsonObject_PrettyPrintTo_Tests.cpp b/test/JsonObject_PrettyPrintTo_Tests.cpp index f15a3734..ba05c6d5 100644 --- a/test/JsonObject_PrettyPrintTo_Tests.cpp +++ b/test/JsonObject_PrettyPrintTo_Tests.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include using namespace ArduinoJson; diff --git a/test/JsonObject_PrintTo_Tests.cpp b/test/JsonObject_PrintTo_Tests.cpp index f45b4a13..bb980e61 100644 --- a/test/JsonObject_PrintTo_Tests.cpp +++ b/test/JsonObject_PrintTo_Tests.cpp @@ -7,10 +7,10 @@ #include #include #include -#include +#include #include -using namespace ArduinoJson; +using namespace ArduinoJson; using namespace ArduinoJson::Internals; class JsonObject_PrintTo_Tests : public testing::Test { diff --git a/test/JsonParser_Array_Tests.cpp b/test/JsonParser_Array_Tests.cpp index 64f8b889..abb63356 100644 --- a/test/JsonParser_Array_Tests.cpp +++ b/test/JsonParser_Array_Tests.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include using namespace ArduinoJson; diff --git a/test/JsonParser_Object_Tests.cpp b/test/JsonParser_Object_Tests.cpp index 5d25c536..047320e0 100644 --- a/test/JsonParser_Object_Tests.cpp +++ b/test/JsonParser_Object_Tests.cpp @@ -7,7 +7,7 @@ #include #include #include -#include +#include using namespace ArduinoJson; diff --git a/test/JsonValue_Storage_Tests.cpp b/test/JsonValue_Storage_Tests.cpp deleted file mode 100644 index 29af9ab0..00000000 --- a/test/JsonValue_Storage_Tests.cpp +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright Benoit Blanchon 2014 -// MIT License -// -// Arduino JSON library -// https://github.com/bblanchon/ArduinoJson - -#include -#include -#include -#include -#include - -using namespace ArduinoJson; - -class JsonValue_Storage_Tests : public ::testing::Test { - protected: - template - void testValue(T expected) { - jsonValue.set(expected); - EXPECT_EQ(expected, jsonValue.as()); - } - - template - void testReference(T &expected) { - jsonValue.set(expected); - EXPECT_EQ(expected, jsonValue.as()); - } - - JsonValue jsonValue; -}; - -TEST_F(JsonValue_Storage_Tests, Double) { testValue(123.45); } -TEST_F(JsonValue_Storage_Tests, False) { testValue(false); } -TEST_F(JsonValue_Storage_Tests, Float) { testValue(123.45f); } -TEST_F(JsonValue_Storage_Tests, Null) { testValue(NULL); } -TEST_F(JsonValue_Storage_Tests, SChar) { testValue(123); } -TEST_F(JsonValue_Storage_Tests, SInt) { testValue(123); } -TEST_F(JsonValue_Storage_Tests, SLong) { testValue(123L); } -TEST_F(JsonValue_Storage_Tests, SShort) { testValue(123); } -TEST_F(JsonValue_Storage_Tests, String) { testValue("hello"); } -TEST_F(JsonValue_Storage_Tests, True) { testValue(true); } -TEST_F(JsonValue_Storage_Tests, UChar) { testValue(123); } -TEST_F(JsonValue_Storage_Tests, UInt) { testValue(123U); } -TEST_F(JsonValue_Storage_Tests, ULong) { testValue(123UL); } -TEST_F(JsonValue_Storage_Tests, UShort) { testValue(123); } - -TEST_F(JsonValue_Storage_Tests, CanStoreObject) { - StaticJsonBuffer<200> json; - JsonObject &object = json.createObject(); - - testReference(object); -} diff --git a/test/JsonValue_Comparison_Tests.cpp b/test/JsonVariant_Comparison_Tests.cpp similarity index 75% rename from test/JsonValue_Comparison_Tests.cpp rename to test/JsonVariant_Comparison_Tests.cpp index 36ae2789..401fc645 100644 --- a/test/JsonValue_Comparison_Tests.cpp +++ b/test/JsonVariant_Comparison_Tests.cpp @@ -5,12 +5,12 @@ // https://github.com/bblanchon/ArduinoJson #include -#include +#include #include "Printers.hpp" using namespace ArduinoJson; -class JsonValue_Comparison_Tests : public ::testing::Test { +class JsonVariant_Comparison_Tests : public ::testing::Test { protected: template void testValue(T low, T mid, T high) { @@ -52,45 +52,45 @@ class JsonValue_Comparison_Tests : public ::testing::Test { EXPECT_NE(expected, jsonValue); // operator!= } - JsonValue jsonValue; + JsonVariant jsonValue; }; -TEST_F(JsonValue_Comparison_Tests, Double) { +TEST_F(JsonVariant_Comparison_Tests, Double) { testValue(123.44, 123.45, 123.46); } -TEST_F(JsonValue_Comparison_Tests, Float) { +TEST_F(JsonVariant_Comparison_Tests, Float) { testValue(123.44f, 123.45f, 123.46f); } -TEST_F(JsonValue_Comparison_Tests, SChar) { +TEST_F(JsonVariant_Comparison_Tests, SChar) { testValue(122, 123, 124); } -TEST_F(JsonValue_Comparison_Tests, SInt) { +TEST_F(JsonVariant_Comparison_Tests, SInt) { testValue(122, 123, 124); } -TEST_F(JsonValue_Comparison_Tests, SLong) { +TEST_F(JsonVariant_Comparison_Tests, SLong) { testValue(122L, 123L, 124L); } -TEST_F(JsonValue_Comparison_Tests, SShort) { +TEST_F(JsonVariant_Comparison_Tests, SShort) { testValue(122, 123, 124); } -TEST_F(JsonValue_Comparison_Tests, UChar) { +TEST_F(JsonVariant_Comparison_Tests, UChar) { testValue(122, 123, 124); } -TEST_F(JsonValue_Comparison_Tests, UInt) { +TEST_F(JsonVariant_Comparison_Tests, UInt) { testValue(122, 123, 124); } -TEST_F(JsonValue_Comparison_Tests, ULong) { +TEST_F(JsonVariant_Comparison_Tests, ULong) { testValue(122L, 123L, 124L); } -TEST_F(JsonValue_Comparison_Tests, UShort) { +TEST_F(JsonVariant_Comparison_Tests, UShort) { testValue(122, 123, 124); } diff --git a/test/JsonValue_Copy_Tests.cpp b/test/JsonVariant_Copy_Tests.cpp similarity index 68% rename from test/JsonValue_Copy_Tests.cpp rename to test/JsonVariant_Copy_Tests.cpp index 80e26912..ad74a248 100644 --- a/test/JsonValue_Copy_Tests.cpp +++ b/test/JsonVariant_Copy_Tests.cpp @@ -8,18 +8,18 @@ #include #include #include -#include +#include using namespace ArduinoJson; -class JsonValue_Copy_Tests : public ::testing::Test { +class JsonVariant_Copy_Tests : public ::testing::Test { protected: StaticJsonBuffer<200> json; - JsonValue jsonValue1; - JsonValue jsonValue2; + JsonVariant jsonValue1; + JsonVariant jsonValue2; }; -TEST_F(JsonValue_Copy_Tests, IntegersAreCopiedByValue) { +TEST_F(JsonVariant_Copy_Tests, IntegersAreCopiedByValue) { jsonValue1 = 123; jsonValue2 = jsonValue1; jsonValue1 = 456; @@ -27,7 +27,7 @@ TEST_F(JsonValue_Copy_Tests, IntegersAreCopiedByValue) { EXPECT_EQ(123, jsonValue2.as()); } -TEST_F(JsonValue_Copy_Tests, DoublesAreCopiedByValue) { +TEST_F(JsonVariant_Copy_Tests, DoublesAreCopiedByValue) { jsonValue1 = 123.45; jsonValue2 = jsonValue1; jsonValue1 = 456.78; @@ -35,7 +35,7 @@ TEST_F(JsonValue_Copy_Tests, DoublesAreCopiedByValue) { EXPECT_EQ(123.45, jsonValue2.as()); } -TEST_F(JsonValue_Copy_Tests, BooleansAreCopiedByValue) { +TEST_F(JsonVariant_Copy_Tests, BooleansAreCopiedByValue) { jsonValue1 = true; jsonValue2 = jsonValue1; jsonValue1 = false; @@ -43,7 +43,7 @@ TEST_F(JsonValue_Copy_Tests, BooleansAreCopiedByValue) { EXPECT_TRUE(jsonValue2.as()); } -TEST_F(JsonValue_Copy_Tests, StringsAreCopiedByValue) { +TEST_F(JsonVariant_Copy_Tests, StringsAreCopiedByValue) { jsonValue1 = "hello"; jsonValue2 = jsonValue1; jsonValue1 = "world"; @@ -51,7 +51,7 @@ TEST_F(JsonValue_Copy_Tests, StringsAreCopiedByValue) { EXPECT_STREQ("hello", jsonValue2.as()); } -TEST_F(JsonValue_Copy_Tests, ObjectsAreCopiedByReference) { +TEST_F(JsonVariant_Copy_Tests, ObjectsAreCopiedByReference) { JsonObject &object = json.createObject(); jsonValue1 = object; @@ -61,7 +61,7 @@ TEST_F(JsonValue_Copy_Tests, ObjectsAreCopiedByReference) { EXPECT_EQ(1, jsonValue1.asObject().size()); } -TEST_F(JsonValue_Copy_Tests, ArraysAreCopiedByReference) { +TEST_F(JsonVariant_Copy_Tests, ArraysAreCopiedByReference) { JsonArray &array = json.createArray(); jsonValue1 = array; diff --git a/test/JsonVariant_Storage_Tests.cpp b/test/JsonVariant_Storage_Tests.cpp new file mode 100644 index 00000000..3ef71981 --- /dev/null +++ b/test/JsonVariant_Storage_Tests.cpp @@ -0,0 +1,52 @@ +// Copyright Benoit Blanchon 2014 +// MIT License +// +// Arduino JSON library +// https://github.com/bblanchon/ArduinoJson + +#include +#include +#include +#include +#include + +using namespace ArduinoJson; + +class JsonVariant_Storage_Tests : public ::testing::Test { + protected: + template + void testValue(T expected) { + jsonValue.set(expected); + EXPECT_EQ(expected, jsonValue.as()); + } + + template + void testReference(T &expected) { + jsonValue.set(expected); + EXPECT_EQ(expected, jsonValue.as()); + } + + JsonVariant jsonValue; +}; + +TEST_F(JsonVariant_Storage_Tests, Double) { testValue(123.45); } +TEST_F(JsonVariant_Storage_Tests, False) { testValue(false); } +TEST_F(JsonVariant_Storage_Tests, Float) { testValue(123.45f); } +TEST_F(JsonVariant_Storage_Tests, Null) { testValue(NULL); } +TEST_F(JsonVariant_Storage_Tests, SChar) { testValue(123); } +TEST_F(JsonVariant_Storage_Tests, SInt) { testValue(123); } +TEST_F(JsonVariant_Storage_Tests, SLong) { testValue(123L); } +TEST_F(JsonVariant_Storage_Tests, SShort) { testValue(123); } +TEST_F(JsonVariant_Storage_Tests, String) { testValue("hello"); } +TEST_F(JsonVariant_Storage_Tests, True) { testValue(true); } +TEST_F(JsonVariant_Storage_Tests, UChar) { testValue(123); } +TEST_F(JsonVariant_Storage_Tests, UInt) { testValue(123U); } +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(); + + testReference(object); +} diff --git a/test/Printers.cpp b/test/Printers.cpp index d19268bf..01e9085e 100644 --- a/test/Printers.cpp +++ b/test/Printers.cpp @@ -7,12 +7,12 @@ #include "Printers.hpp" std::ostream& ArduinoJson::operator<<(std::ostream& os, - const ArduinoJson::JsonValue& v) { + const ArduinoJson::JsonVariant& v) { if (v.is()) os << v.as(); else if (v.is()) os << v.as(); else - os << "JsonValue"; // TODO + os << "JsonVariant"; // TODO return os; } diff --git a/test/Printers.hpp b/test/Printers.hpp index f2d3c586..2b80ff8e 100644 --- a/test/Printers.hpp +++ b/test/Printers.hpp @@ -6,9 +6,9 @@ #pragma once -#include +#include #include namespace ArduinoJson { -std::ostream& operator<<(std::ostream& os, const ArduinoJson::JsonValue& v); +std::ostream& operator<<(std::ostream& os, const ArduinoJson::JsonVariant& v); } diff --git a/test/StaticJsonBufferTests.cpp b/test/StaticJsonBufferTests.cpp index 2826f3c4..1682d615 100644 --- a/test/StaticJsonBufferTests.cpp +++ b/test/StaticJsonBufferTests.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include using namespace ArduinoJson;