feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

as<char*>() now returns true when input is null (issue #330)

Browse Source
This commit is contained in:
Benoit Blanchon
2016-08-15 12:24:08 +02:00
parent a498abc14a
commit 96f486001d
3 changed files with 222 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -1,6 +1,11 @@
ArduinoJson: change log ArduinoJson: change log
======================= =======================
HEAD
----
* `as<char*>()` now returns `true` when input is `null` (issue #330)
v5.6.4 v5.6.4
------ ------

9
include/ArduinoJson/JsonVariant.hpp
View File

@ -300,8 +300,13 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
return T(); return T();
} }
// DEPRECATED: use as<char*>() instead
const char *asString() const; const char *asString() const;
// DEPRECATED: use as<JsonArray>() instead
JsonArray &asArray() const; JsonArray &asArray() const;
// DEPRECATED: use as<JsonObject>() instead
JsonObject &asObject() const; JsonObject &asObject() const;
private: private:
@ -324,7 +329,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
return _type == Internals::JSON_OBJECT; return _type == Internals::JSON_OBJECT;
} }
bool isString() const { bool isString() const {
return _type == Internals::JSON_STRING; return _type == Internals::JSON_STRING ||
_type == Internals::JSON_UNPARSED && _content.asString &&
!strcmp("null", _content.asString);
} }
// The current type of the variant // The current type of the variant

271
test/JsonVariant_Is_Tests.cpp
View File

@ -5,8 +5,8 @@
// https://github.com/bblanchon/ArduinoJson // https://github.com/bblanchon/ArduinoJson
// If you like this project, please add a star! // If you like this project, please add a star!
#include <gtest/gtest.h>
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <gtest/gtest.h>
#define SUITE JsonVariant_Is_Tests #define SUITE JsonVariant_Is_Tests
@ -34,75 +34,222 @@ void assertIs(JsonArray& value) {
ASSERT_TRUE(variant.is<TTo>()); ASSERT_TRUE(variant.is<TTo>());
} }
TEST(SUITE, ArrayIsArry) { assertIs<JsonArray&>(JsonArray::invalid()); } TEST(SUITE, ArrayIsArry) {
TEST(SUITE, ArrayIsBool) { assertIsNot<bool>(JsonArray::invalid()); } assertIs<JsonArray&>(JsonArray::invalid());
TEST(SUITE, ArrayIsDouble) { assertIsNot<double>(JsonArray::invalid()); } }
TEST(SUITE, ArrayIsFloat) { assertIsNot<float>(JsonArray::invalid()); } TEST(SUITE, ArrayIsBool) {
TEST(SUITE, ArrayIsInt) { assertIsNot<int>(JsonArray::invalid()); } assertIsNot<bool>(JsonArray::invalid());
TEST(SUITE, ArrayIsLong) { assertIsNot<long>(JsonArray::invalid()); } }
TEST(SUITE, ArrayIsString) { assertIsNot<const char*>(JsonArray::invalid()); } TEST(SUITE, ArrayIsDouble) {
assertIsNot<double>(JsonArray::invalid());
}
TEST(SUITE, ArrayIsFloat) {
assertIsNot<float>(JsonArray::invalid());
}
TEST(SUITE, ArrayIsInt) {
assertIsNot<int>(JsonArray::invalid());
}
TEST(SUITE, ArrayIsLong) {
assertIsNot<long>(JsonArray::invalid());
}
TEST(SUITE, ArrayIsString) {
assertIsNot<const char*>(JsonArray::invalid());
}
TEST(SUITE, BoolIsArray) { assertIsNot<JsonArray&>(true); } TEST(SUITE, BoolIsArray) {
TEST(SUITE, BoolIsBool) { assertIs<bool>(true); } assertIsNot<JsonArray&>(true);
TEST(SUITE, BoolIsDouble) { assertIsNot<double>(true); } }
TEST(SUITE, BoolIsFloat) { assertIsNot<float>(true); } TEST(SUITE, BoolIsBool) {
TEST(SUITE, BoolIsInt) { assertIsNot<int>(true); } assertIs<bool>(true);
TEST(SUITE, BoolIsLong) { assertIsNot<long>(true); } }
TEST(SUITE, BoolIsString) { assertIsNot<const char*>(true); } TEST(SUITE, BoolIsDouble) {
assertIsNot<double>(true);
}
TEST(SUITE, BoolIsFloat) {
assertIsNot<float>(true);
}
TEST(SUITE, BoolIsInt) {
assertIsNot<int>(true);
}
TEST(SUITE, BoolIsLong) {
assertIsNot<long>(true);
}
TEST(SUITE, BoolIsString) {
assertIsNot<const char*>(true);
}
TEST(SUITE, DoubleIsArray) { assertIsNot<JsonArray&>(4.2); } TEST(SUITE, DoubleIsArray) {
TEST(SUITE, DoubleIsBool) { assertIsNot<bool>(4.2); } assertIsNot<JsonArray&>(4.2);
TEST(SUITE, DoubleIsDouble) { assertIs<double>(4.2); } }
TEST(SUITE, DoubleIsFloat) { assertIs<float>(4.2); } TEST(SUITE, DoubleIsBool) {
TEST(SUITE, DoubleIsInt) { assertIsNot<int>(4.2); } assertIsNot<bool>(4.2);
TEST(SUITE, DoubleIsLong) { assertIsNot<long>(4.2); } }
TEST(SUITE, DoubleIsString) { assertIsNot<const char*>(4.2); } TEST(SUITE, DoubleIsDouble) {
assertIs<double>(4.2);
}
TEST(SUITE, DoubleIsFloat) {
assertIs<float>(4.2);
}
TEST(SUITE, DoubleIsInt) {
assertIsNot<int>(4.2);
}
TEST(SUITE, DoubleIsLong) {
assertIsNot<long>(4.2);
}
TEST(SUITE, DoubleIsString) {
assertIsNot<const char*>(4.2);
}
TEST(SUITE, LongIsArray) { assertIsNot<JsonArray&>(42L); } TEST(SUITE, LongIsArray) {
TEST(SUITE, LongIsBool) { assertIsNot<bool>(42L); } assertIsNot<JsonArray&>(42L);
TEST(SUITE, LongIsDouble) { assertIsNot<double>(42L); } }
TEST(SUITE, LongIsFloat) { assertIsNot<float>(42L); } TEST(SUITE, LongIsBool) {
TEST(SUITE, LongIsInt) { assertIs<int>(42L); } assertIsNot<bool>(42L);
TEST(SUITE, LongIsLong) { assertIs<long>(42L); } }
TEST(SUITE, LongIsString) { assertIsNot<const char*>(42L); } TEST(SUITE, LongIsDouble) {
assertIsNot<double>(42L);
}
TEST(SUITE, LongIsFloat) {
assertIsNot<float>(42L);
}
TEST(SUITE, LongIsInt) {
assertIs<int>(42L);
}
TEST(SUITE, LongIsLong) {
assertIs<long>(42L);
}
TEST(SUITE, LongIsString) {
assertIsNot<const char*>(42L);
}
TEST(SUITE, StringIsArray) { assertIsNot<JsonArray&>("42"); } TEST(SUITE, StringIsArray) {
TEST(SUITE, StringIsBool) { assertIsNot<bool>("42"); } assertIsNot<JsonArray&>("42");
TEST(SUITE, StringIsDouble) { assertIsNot<double>("42"); } }
TEST(SUITE, StringIsFloat) { assertIsNot<float>("42"); } TEST(SUITE, StringIsBool) {
TEST(SUITE, StringIsInt) { assertIsNot<int>("42"); } assertIsNot<bool>("42");
TEST(SUITE, StringIsLong) { assertIsNot<long>("42"); } }
TEST(SUITE, StringIsString) { assertIs<const char*>("42"); } TEST(SUITE, StringIsDouble) {
assertIsNot<double>("42");
}
TEST(SUITE, StringIsFloat) {
assertIsNot<float>("42");
}
TEST(SUITE, StringIsInt) {
assertIsNot<int>("42");
}
TEST(SUITE, StringIsLong) {
assertIsNot<long>("42");
}
TEST(SUITE, StringIsString) {
assertIs<const char*>("42");
}
TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(RawJson("true")); } TEST(SUITE, UnparsedTrueIsArray) {
TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(RawJson("true")); } assertIsNot<JsonArray&>(RawJson("true"));
TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(RawJson("true")); } }
TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(RawJson("true")); } TEST(SUITE, UnparsedTrueIsBool) {
TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(RawJson("true")); } assertIs<bool>(RawJson("true"));
TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(RawJson("true")); } }
TEST(SUITE, UnparsedTrueIsString) { assertIsNot<const char*>(RawJson("true")); } TEST(SUITE, UnparsedTrueIsDouble) {
assertIsNot<double>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsFloat) {
assertIsNot<float>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsInt) {
assertIsNot<int>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsLong) {
assertIsNot<long>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsString) {
assertIsNot<const char*>(RawJson("true"));
}
TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(RawJson("false")); } TEST(SUITE, UnparsedFalseIsArray) {
TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(RawJson("false")); } assertIsNot<JsonArray&>(RawJson("false"));
TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(RawJson("false")); } }
TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(RawJson("false")); } TEST(SUITE, UnparsedFalseIsBool) {
TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(RawJson("false")); } assertIs<bool>(RawJson("false"));
TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(RawJson("false")); } }
TEST(SUITE, UnparsedFalseIsDouble) {
assertIsNot<double>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsFloat) {
assertIsNot<float>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsInt) {
assertIsNot<int>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsLong) {
assertIsNot<long>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsString) { TEST(SUITE, UnparsedFalseIsString) {
assertIsNot<const char*>(RawJson("false")); assertIsNot<const char*>(RawJson("false"));
} }
TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(RawJson("42")); } TEST(SUITE, UnparsedIntIsArray) {
TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(RawJson("42")); } assertIsNot<JsonArray&>(RawJson("42"));
TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(RawJson("42")); } }
TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(RawJson("42")); } TEST(SUITE, UnparsedIntIsBool) {
TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(RawJson("42")); } assertIsNot<bool>(RawJson("42"));
TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(RawJson("42")); } }
TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(RawJson("42")); } TEST(SUITE, UnparsedIntIsDouble) {
assertIsNot<double>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsFloat) {
assertIsNot<float>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsInt) {
assertIs<int>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsLong) {
assertIs<long>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsString) {
assertIsNot<const char*>(RawJson("42"));
}
TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(RawJson("4.2e-10")); } TEST(SUITE, UnparsedFloatIsBool) {
TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(RawJson("4.2e-10")); } assertIsNot<bool>(RawJson("4.2e-10"));
TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(RawJson("4.2e-10")); } }
TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(RawJson("4.2e-10")); } TEST(SUITE, UnparsedFloatIsDouble) {
TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(RawJson("4.2e-10")); } assertIs<double>(RawJson("4.2e-10"));
TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(RawJson("4.2")); } }
TEST(SUITE, UnparsedFloatIsFloat) {
assertIs<float>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsInt) {
assertIsNot<int>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsLong) {
assertIsNot<long>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsStr) {
assertIsNot<const char*>(RawJson("4.2"));
}
TEST(SUITE, UnparsedNullIsArray) {
assertIsNot<JsonArray&>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsBool) {
assertIsNot<bool>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsDouble) {
assertIsNot<double>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsFloat) {
assertIsNot<float>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsInt) {
assertIsNot<int>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsLong) {
assertIsNot<long>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsConstCharPtr) {
assertIs<const char*>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsCharPtr) {
assertIs<char*>(RawJson("null"));
}