[209] | 1 | // Copyright Benoit Blanchon 2014-2016
|
---|
| 2 | // MIT License
|
---|
| 3 | //
|
---|
| 4 | // Arduino JSON library
|
---|
| 5 | // https://github.com/bblanchon/ArduinoJson
|
---|
| 6 | // If you like this project, please add a star!
|
---|
| 7 |
|
---|
| 8 | #include <gtest/gtest.h>
|
---|
| 9 | #include <ArduinoJson.h>
|
---|
| 10 |
|
---|
| 11 | #define SUITE JsonVariant_Is_Tests
|
---|
| 12 |
|
---|
| 13 | using namespace ArduinoJson::Internals;
|
---|
| 14 |
|
---|
| 15 | template <typename TTo, typename TFrom>
|
---|
| 16 | void assertIsNot(TFrom value) {
|
---|
| 17 | JsonVariant variant = value;
|
---|
| 18 | ASSERT_FALSE(variant.is<TTo>());
|
---|
| 19 | }
|
---|
| 20 |
|
---|
| 21 | template <typename TTo>
|
---|
| 22 | void assertIsNot(JsonArray& value) {
|
---|
| 23 | JsonVariant variant = value;
|
---|
| 24 | ASSERT_FALSE(variant.is<TTo>());
|
---|
| 25 | }
|
---|
| 26 |
|
---|
| 27 | template <typename TTo, typename TFrom>
|
---|
| 28 | void assertIs(TFrom value) {
|
---|
| 29 | JsonVariant variant = value;
|
---|
| 30 | ASSERT_TRUE(variant.is<TTo>());
|
---|
| 31 | }
|
---|
| 32 |
|
---|
| 33 | template <typename TTo>
|
---|
| 34 | void assertIs(JsonArray& value) {
|
---|
| 35 | JsonVariant variant = value;
|
---|
| 36 | ASSERT_TRUE(variant.is<TTo>());
|
---|
| 37 | }
|
---|
| 38 |
|
---|
| 39 | TEST(SUITE, ArrayIsArry) { assertIs<JsonArray&>(JsonArray::invalid()); }
|
---|
| 40 | TEST(SUITE, ArrayIsBool) { assertIsNot<bool>(JsonArray::invalid()); }
|
---|
| 41 | TEST(SUITE, ArrayIsDouble) { assertIsNot<double>(JsonArray::invalid()); }
|
---|
| 42 | TEST(SUITE, ArrayIsFloat) { assertIsNot<float>(JsonArray::invalid()); }
|
---|
| 43 | TEST(SUITE, ArrayIsInt) { assertIsNot<int>(JsonArray::invalid()); }
|
---|
| 44 | TEST(SUITE, ArrayIsLong) { assertIsNot<long>(JsonArray::invalid()); }
|
---|
| 45 | TEST(SUITE, ArrayIsString) { assertIsNot<const char*>(JsonArray::invalid()); }
|
---|
| 46 |
|
---|
| 47 | TEST(SUITE, BoolIsArray) { assertIsNot<JsonArray&>(true); }
|
---|
| 48 | TEST(SUITE, BoolIsBool) { assertIs<bool>(true); }
|
---|
| 49 | TEST(SUITE, BoolIsDouble) { assertIsNot<double>(true); }
|
---|
| 50 | TEST(SUITE, BoolIsFloat) { assertIsNot<float>(true); }
|
---|
| 51 | TEST(SUITE, BoolIsInt) { assertIsNot<int>(true); }
|
---|
| 52 | TEST(SUITE, BoolIsLong) { assertIsNot<long>(true); }
|
---|
| 53 | TEST(SUITE, BoolIsString) { assertIsNot<const char*>(true); }
|
---|
| 54 |
|
---|
| 55 | TEST(SUITE, DoubleIsArray) { assertIsNot<JsonArray&>(4.2); }
|
---|
| 56 | TEST(SUITE, DoubleIsBool) { assertIsNot<bool>(4.2); }
|
---|
| 57 | TEST(SUITE, DoubleIsDouble) { assertIs<double>(4.2); }
|
---|
| 58 | TEST(SUITE, DoubleIsFloat) { assertIs<float>(4.2); }
|
---|
| 59 | TEST(SUITE, DoubleIsInt) { assertIsNot<int>(4.2); }
|
---|
| 60 | TEST(SUITE, DoubleIsLong) { assertIsNot<long>(4.2); }
|
---|
| 61 | TEST(SUITE, DoubleIsString) { assertIsNot<const char*>(4.2); }
|
---|
| 62 |
|
---|
| 63 | TEST(SUITE, LongIsArray) { assertIsNot<JsonArray&>(42L); }
|
---|
| 64 | TEST(SUITE, LongIsBool) { assertIsNot<bool>(42L); }
|
---|
| 65 | TEST(SUITE, LongIsDouble) { assertIsNot<double>(42L); }
|
---|
| 66 | TEST(SUITE, LongIsFloat) { assertIsNot<float>(42L); }
|
---|
| 67 | TEST(SUITE, LongIsInt) { assertIs<int>(42L); }
|
---|
| 68 | TEST(SUITE, LongIsLong) { assertIs<long>(42L); }
|
---|
| 69 | TEST(SUITE, LongIsString) { assertIsNot<const char*>(42L); }
|
---|
| 70 |
|
---|
| 71 | TEST(SUITE, StringIsArray) { assertIsNot<JsonArray&>("42"); }
|
---|
| 72 | TEST(SUITE, StringIsBool) { assertIsNot<bool>("42"); }
|
---|
| 73 | TEST(SUITE, StringIsDouble) { assertIsNot<double>("42"); }
|
---|
| 74 | TEST(SUITE, StringIsFloat) { assertIsNot<float>("42"); }
|
---|
| 75 | TEST(SUITE, StringIsInt) { assertIsNot<int>("42"); }
|
---|
| 76 | TEST(SUITE, StringIsLong) { assertIsNot<long>("42"); }
|
---|
| 77 | TEST(SUITE, StringIsString) { assertIs<const char*>("42"); }
|
---|
| 78 |
|
---|
| 79 | TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(Unparsed("true")); }
|
---|
| 80 | TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(Unparsed("true")); }
|
---|
| 81 | TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(Unparsed("true")); }
|
---|
| 82 | TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(Unparsed("true")); }
|
---|
| 83 | TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(Unparsed("true")); }
|
---|
| 84 | TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(Unparsed("true")); }
|
---|
| 85 | TEST(SUITE, UnparsedTrueIsString) {
|
---|
| 86 | assertIsNot<const char*>(Unparsed("true"));
|
---|
| 87 | }
|
---|
| 88 |
|
---|
| 89 | TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(Unparsed("false")); }
|
---|
| 90 | TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(Unparsed("false")); }
|
---|
| 91 | TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(Unparsed("false")); }
|
---|
| 92 | TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(Unparsed("false")); }
|
---|
| 93 | TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(Unparsed("false")); }
|
---|
| 94 | TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(Unparsed("false")); }
|
---|
| 95 | TEST(SUITE, UnparsedFalseIsString) {
|
---|
| 96 | assertIsNot<const char*>(Unparsed("false"));
|
---|
| 97 | }
|
---|
| 98 |
|
---|
| 99 | TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(Unparsed("42")); }
|
---|
| 100 | TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(Unparsed("42")); }
|
---|
| 101 | TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(Unparsed("42")); }
|
---|
| 102 | TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(Unparsed("42")); }
|
---|
| 103 | TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(Unparsed("42")); }
|
---|
| 104 | TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(Unparsed("42")); }
|
---|
| 105 | TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(Unparsed("42")); }
|
---|
| 106 |
|
---|
| 107 | TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(Unparsed("4.2e-10")); }
|
---|
| 108 | TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(Unparsed("4.2e-10")); }
|
---|
| 109 | TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(Unparsed("4.2e-10")); }
|
---|
| 110 | TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(Unparsed("4.2e-10")); }
|
---|
| 111 | TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(Unparsed("4.2e-10")); }
|
---|
| 112 | TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(Unparsed("4.2")); }
|
---|