mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-19 00:41:43 +00:00
Prepare wpiutil for merge into allwpilib.
This commit is contained in:
Peter Johnson
560
wpiutil/src/test/native/cpp/json/unit-conversions.cpp
Normal file
560
wpiutil/src/test/native/cpp/json/unit-conversions.cpp
Normal file
@@ -0,0 +1,560 @@
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Modifications Copyright (c) FIRST 2017. All Rights Reserved. */
|
||||
/* Open Source Software - may be modified and shared by FRC teams. The code */
|
||||
/* must be accompanied by the FIRST BSD license file in the root directory of */
|
||||
/* the project. */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/*
|
||||
__ _____ _____ _____
|
||||
__| | __| | | | JSON for Modern C++ (test suite)
|
||||
| | |__ | | | | | | version 2.1.1
|
||||
|_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
|
||||
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
|
||||
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include "unit-json.h"
|
||||
using wpi::json;
|
||||
using wpi::JsonTest;
|
||||
|
||||
#include <deque>
|
||||
//#include <forward_list>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
|
||||
template <typename T>
|
||||
class JsonGetObjectTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetObjectTest() : j(o_reference) {}
|
||||
|
||||
protected:
|
||||
json::object_t o_reference = {{"object", json::object()}, {"array", {1, 2, 3, 4}}, {"number", 42}, {"boolean", false}, {"null", nullptr}, {"string", "Hello world"} };
|
||||
json j;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<
|
||||
json::object_t
|
||||
, std::map<json::string_t, json>
|
||||
, std::multimap<json::string_t, json>
|
||||
, std::unordered_map<json::string_t, json>
|
||||
, std::unordered_multimap<json::string_t, json>
|
||||
> JsonGetObjectTestTypes;
|
||||
TYPED_TEST_CASE(JsonGetObjectTest, JsonGetObjectTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetObjectTest, Explicit)
|
||||
{
|
||||
TypeParam o = (this->j).template get<TypeParam>();
|
||||
EXPECT_EQ(json(o), this->j);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetObjectTest, Implicit)
|
||||
{
|
||||
TypeParam o = this->j;
|
||||
EXPECT_EQ(json(o), this->j);
|
||||
}
|
||||
|
||||
// exception in case of a non-object type
|
||||
TEST(JsonGetObjectExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::array).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is array");
|
||||
EXPECT_THROW_MSG(json(json::value_t::string).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is string");
|
||||
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is boolean");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::object_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is number");
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class JsonGetArrayTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetArrayTest() : j(a_reference) {}
|
||||
|
||||
protected:
|
||||
json::array_t a_reference {json(1), json(1u), json(2.2), json(false), json("string"), json()};
|
||||
json j;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<json::array_t, std::list<json>,
|
||||
/*std::forward_list<json>,*/ std::vector<json>,
|
||||
std::deque<json>>
|
||||
JsonGetArrayTestTypes;
|
||||
TYPED_TEST_CASE(JsonGetArrayTest, JsonGetArrayTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetArrayTest, Explicit)
|
||||
{
|
||||
TypeParam a = (this->j).template get<TypeParam>();
|
||||
EXPECT_EQ(json(a), this->j);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetArrayTest, Implicit)
|
||||
{
|
||||
TypeParam a = this->j;
|
||||
EXPECT_EQ(json(a), this->j);
|
||||
}
|
||||
|
||||
#if !defined(JSON_NOEXCEPTION)
|
||||
// reserve is called on containers that supports it
|
||||
TEST(JsonGetArrayAdditionalTest, ExplicitStdVectorReserve)
|
||||
{
|
||||
json::array_t a_reference {json(1), json(1u), json(2.2), json(false), json("string"), json()};
|
||||
json j(a_reference);
|
||||
|
||||
// making the call to from_json throw in order to check capacity
|
||||
std::vector<float> v;
|
||||
EXPECT_THROW(wpi::from_json(j, v), json::type_error);
|
||||
EXPECT_EQ(v.capacity(), j.size());
|
||||
|
||||
// make sure all values are properly copied
|
||||
std::vector<int> v2 = json({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
|
||||
EXPECT_EQ(v2.size(), 10u);
|
||||
}
|
||||
#endif
|
||||
|
||||
// built-in arrays
|
||||
TEST(JsonGetArrayAdditionalTest, ExplicitBuiltinArray)
|
||||
{
|
||||
const char str[] = "a string";
|
||||
const int nbs[] = {0, 1, 2};
|
||||
|
||||
json j2 = nbs;
|
||||
json j3 = str;
|
||||
|
||||
auto v = j2.get<std::vector<int>>();
|
||||
auto s = j3.get<std::string>();
|
||||
EXPECT_TRUE(std::equal(v.begin(), v.end(), std::begin(nbs)));
|
||||
EXPECT_EQ(s, str);
|
||||
}
|
||||
#if 0
|
||||
TEST(JsonGetArrayExceptionTest, ForwardList)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<std::forward_list<json>>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
}
|
||||
#endif
|
||||
TEST(JsonGetArrayExceptionTest, StdVector)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<std::vector<json>>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
}
|
||||
|
||||
// exception in case of a non-array type
|
||||
TEST(JsonGetArrayExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<std::vector<int>>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::string).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is string");
|
||||
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is boolean");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::array_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is number");
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class JsonGetStringTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetStringTest() : j(s_reference) {}
|
||||
|
||||
protected:
|
||||
json::string_t s_reference {"Hello world"};
|
||||
json j;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<json::string_t, std::string> JsonGetStringTestTypes;
|
||||
TYPED_TEST_CASE(JsonGetStringTest, JsonGetStringTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetStringTest, Explicit)
|
||||
{
|
||||
TypeParam s = (this->j).template get<TypeParam>();
|
||||
EXPECT_EQ(json(s), this->j);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetStringTest, Implicit)
|
||||
{
|
||||
TypeParam s = this->j;
|
||||
EXPECT_EQ(json(s), this->j);
|
||||
}
|
||||
|
||||
// exception in case of a non-string type
|
||||
TEST(JsonGetStringExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::array).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is array");
|
||||
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is boolean");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::string_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be string, but is number");
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class JsonGetBooleanTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetBooleanTest() : j(b_reference) {}
|
||||
|
||||
protected:
|
||||
json::boolean_t b_reference {true};
|
||||
json j;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<json::boolean_t, bool> JsonGetBooleanTestTypes;
|
||||
TYPED_TEST_CASE(JsonGetBooleanTest, JsonGetBooleanTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetBooleanTest, Explicit)
|
||||
{
|
||||
TypeParam b = (this->j).template get<TypeParam>();
|
||||
EXPECT_EQ(json(b), this->j);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetBooleanTest, Implicit)
|
||||
{
|
||||
TypeParam b = this->j;
|
||||
EXPECT_EQ(json(b), this->j);
|
||||
}
|
||||
|
||||
// exception in case of a non-string type
|
||||
TEST(JsonGetBooleanExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::array).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is array");
|
||||
EXPECT_THROW_MSG(json(json::value_t::string).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is string");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is number");
|
||||
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::boolean_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be boolean, but is number");
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class JsonGetIntegerTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetIntegerTest() : j(n_reference), j_unsigned(n_unsigned_reference) {}
|
||||
|
||||
protected:
|
||||
json::number_integer_t n_reference {42};
|
||||
json j;
|
||||
json::number_unsigned_t n_unsigned_reference {42u};
|
||||
json j_unsigned;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<
|
||||
short
|
||||
, unsigned short
|
||||
, int
|
||||
, unsigned int
|
||||
, long
|
||||
, unsigned long
|
||||
, long long
|
||||
, unsigned long long
|
||||
, int8_t
|
||||
, int16_t
|
||||
, int32_t
|
||||
, int64_t
|
||||
#if 0
|
||||
, int8_fast_t
|
||||
, int16_fast_t
|
||||
, int32_fast_t
|
||||
, int64_fast_t
|
||||
, int8_least_t
|
||||
, int16_least_t
|
||||
, int32_least_t
|
||||
, int64_least_t
|
||||
#endif
|
||||
, uint8_t
|
||||
, uint16_t
|
||||
, uint32_t
|
||||
, uint64_t
|
||||
#if 0
|
||||
, uint8_fast_t
|
||||
, uint16_fast_t
|
||||
, uint32_fast_t
|
||||
, uint64_fast_t
|
||||
, uint8_least_t
|
||||
, uint16_least_t
|
||||
, uint32_least_t
|
||||
, uint64_least_t
|
||||
#endif
|
||||
> JsonGetIntegerTestTypes;
|
||||
|
||||
TYPED_TEST_CASE(JsonGetIntegerTest, JsonGetIntegerTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetIntegerTest, Explicit)
|
||||
{
|
||||
TypeParam n = (this->j).template get<TypeParam>();
|
||||
EXPECT_EQ(json(n), this->j);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetIntegerTest, Implicit)
|
||||
{
|
||||
if (std::is_unsigned<TypeParam>::value)
|
||||
{
|
||||
TypeParam n = this->j_unsigned;
|
||||
EXPECT_EQ(json(n), this->j_unsigned);
|
||||
}
|
||||
else
|
||||
{
|
||||
TypeParam n = this->j;
|
||||
EXPECT_EQ(json(n), this->j);
|
||||
}
|
||||
}
|
||||
|
||||
// exception in case of a non-number type
|
||||
TEST(JsonGetIntegerExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::number_integer_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<json::number_integer_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::array).get<json::number_integer_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is array");
|
||||
EXPECT_THROW_MSG(json(json::value_t::string).get<json::number_integer_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is string");
|
||||
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::number_integer_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is boolean");
|
||||
|
||||
EXPECT_NO_THROW(json(json::value_t::number_float).get<json::number_integer_t>());
|
||||
EXPECT_NO_THROW(json(json::value_t::number_float).get<json::number_unsigned_t>());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class JsonGetFloatTest : public ::testing::Test {
|
||||
public:
|
||||
JsonGetFloatTest() : j(n_reference) {}
|
||||
|
||||
protected:
|
||||
json::number_float_t n_reference {42.23};
|
||||
json j;
|
||||
};
|
||||
|
||||
typedef ::testing::Types<json::number_float_t, float, double>
|
||||
JsonGetFloatTestTypes;
|
||||
|
||||
TYPED_TEST_CASE(JsonGetFloatTest, JsonGetFloatTestTypes);
|
||||
|
||||
TYPED_TEST(JsonGetFloatTest, Explicit)
|
||||
{
|
||||
TypeParam n = (this->j).template get<TypeParam>();
|
||||
EXPECT_LT(std::fabs(JsonTest::GetValue(json(n)).number_float -
|
||||
JsonTest::GetValue(this->j).number_float), 0.001);
|
||||
}
|
||||
|
||||
TYPED_TEST(JsonGetFloatTest, Implicit)
|
||||
{
|
||||
TypeParam n = this->j;
|
||||
EXPECT_LT(std::fabs(JsonTest::GetValue(json(n)).number_float -
|
||||
JsonTest::GetValue(this->j).number_float), 0.001);
|
||||
}
|
||||
|
||||
// exception in case of a non-string type
|
||||
TEST(JsonGetFloatExceptionTest, TypeError)
|
||||
{
|
||||
EXPECT_THROW_MSG(json(json::value_t::null).get<json::number_float_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is null");
|
||||
EXPECT_THROW_MSG(json(json::value_t::object).get<json::number_float_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is object");
|
||||
EXPECT_THROW_MSG(json(json::value_t::array).get<json::number_float_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is array");
|
||||
EXPECT_THROW_MSG(json(json::value_t::string).get<json::number_float_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is string");
|
||||
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::number_float_t>(), json::type_error,
|
||||
"[json.exception.type_error.302] type must be number, but is boolean");
|
||||
|
||||
EXPECT_NO_THROW(json(json::value_t::number_integer).get<json::number_float_t>());
|
||||
EXPECT_NO_THROW(json(json::value_t::number_unsigned).get<json::number_float_t>());
|
||||
}
|
||||
|
||||
TEST(JsonGetEnumTest, Case)
|
||||
{
|
||||
enum c_enum { value_1, value_2 };
|
||||
enum class cpp_enum { value_1, value_2 };
|
||||
|
||||
EXPECT_EQ(json(value_1).get<c_enum>(), value_1);
|
||||
EXPECT_EQ(json(cpp_enum::value_1).get<cpp_enum>(), cpp_enum::value_1);
|
||||
}
|
||||
|
||||
class JsonObjectConversionTest : public ::testing::Test {
|
||||
protected:
|
||||
json j1 = {{"one", 1}, {"two", 2}, {"three", 3}};
|
||||
json j2 = {{"one", 1u}, {"two", 2u}, {"three", 3u}};
|
||||
json j3 = {{"one", 1.1}, {"two", 2.2}, {"three", 3.3}};
|
||||
json j4 = {{"one", true}, {"two", false}, {"three", true}};
|
||||
json j5 = {{"one", "eins"}, {"two", "zwei"}, {"three", "drei"}};
|
||||
};
|
||||
|
||||
TEST_F(JsonObjectConversionTest, StdMap)
|
||||
{
|
||||
auto m1 = j1.get<std::map<std::string, int>>();
|
||||
auto m2 = j2.get<std::map<std::string, unsigned int>>();
|
||||
auto m3 = j3.get<std::map<std::string, double>>();
|
||||
auto m4 = j4.get<std::map<std::string, bool>>();
|
||||
//auto m5 = j5.get<std::map<std::string, std::string>>();
|
||||
}
|
||||
|
||||
TEST_F(JsonObjectConversionTest, StdUnorderedMap)
|
||||
{
|
||||
auto m1 = j1.get<std::unordered_map<std::string, int>>();
|
||||
auto m2 = j2.get<std::unordered_map<std::string, unsigned int>>();
|
||||
auto m3 = j3.get<std::unordered_map<std::string, double>>();
|
||||
auto m4 = j4.get<std::unordered_map<std::string, bool>>();
|
||||
//auto m5 = j5.get<std::unordered_map<std::string, std::string>>();
|
||||
//CHECK(m5["one"] == "eins");
|
||||
}
|
||||
|
||||
TEST_F(JsonObjectConversionTest, StdMultiMap)
|
||||
{
|
||||
auto m1 = j1.get<std::multimap<std::string, int>>();
|
||||
auto m2 = j2.get<std::multimap<std::string, unsigned int>>();
|
||||
auto m3 = j3.get<std::multimap<std::string, double>>();
|
||||
auto m4 = j4.get<std::multimap<std::string, bool>>();
|
||||
//auto m5 = j5.get<std::multimap<std::string, std::string>>();
|
||||
//CHECK(m5["one"] == "eins");
|
||||
}
|
||||
|
||||
TEST_F(JsonObjectConversionTest, StdUnorderedMultiMap)
|
||||
{
|
||||
auto m1 = j1.get<std::unordered_multimap<std::string, int>>();
|
||||
auto m2 = j2.get<std::unordered_multimap<std::string, unsigned int>>();
|
||||
auto m3 = j3.get<std::unordered_multimap<std::string, double>>();
|
||||
auto m4 = j4.get<std::unordered_multimap<std::string, bool>>();
|
||||
//auto m5 = j5.get<std::unordered_multimap<std::string, std::string>>();
|
||||
//CHECK(m5["one"] == "eins");
|
||||
}
|
||||
|
||||
// exception in case of a non-object type
|
||||
TEST_F(JsonObjectConversionTest, Exception)
|
||||
{
|
||||
EXPECT_THROW_MSG((json().get<std::map<std::string, int>>()), json::type_error,
|
||||
"[json.exception.type_error.302] type must be object, but is null");
|
||||
}
|
||||
|
||||
class JsonArrayConversionTest : public ::testing::Test {
|
||||
protected:
|
||||
json j1 = {1, 2, 3, 4};
|
||||
json j2 = {1u, 2u, 3u, 4u};
|
||||
json j3 = {1.2, 2.3, 3.4, 4.5};
|
||||
json j4 = {true, false, true};
|
||||
json j5 = {"one", "two", "three"};
|
||||
};
|
||||
|
||||
TEST_F(JsonArrayConversionTest, StdList)
|
||||
{
|
||||
auto m1 = j1.get<std::list<int>>();
|
||||
auto m2 = j2.get<std::list<unsigned int>>();
|
||||
auto m3 = j3.get<std::list<double>>();
|
||||
auto m4 = j4.get<std::list<bool>>();
|
||||
auto m5 = j5.get<std::list<std::string>>();
|
||||
}
|
||||
|
||||
#if 0
|
||||
TEST_F(JsonArrayConversionTest, StdForwardList)
|
||||
{
|
||||
auto m1 = j1.get<std::forward_list<int>>();
|
||||
auto m2 = j2.get<std::forward_list<unsigned int>>();
|
||||
auto m3 = j3.get<std::forward_list<double>>();
|
||||
auto m4 = j4.get<std::forward_list<bool>>();
|
||||
auto m5 = j5.get<std::forward_list<std::string>>();
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST_F(JsonArrayConversionTest, StdVector)
|
||||
{
|
||||
auto m1 = j1.get<std::vector<int>>();
|
||||
auto m2 = j2.get<std::vector<unsigned int>>();
|
||||
auto m3 = j3.get<std::vector<double>>();
|
||||
auto m4 = j4.get<std::vector<bool>>();
|
||||
auto m5 = j5.get<std::vector<std::string>>();
|
||||
}
|
||||
|
||||
TEST_F(JsonArrayConversionTest, StdDeque)
|
||||
{
|
||||
auto m1 = j1.get<std::deque<int>>();
|
||||
auto m2 = j2.get<std::deque<unsigned int>>();
|
||||
auto m3 = j2.get<std::deque<double>>();
|
||||
auto m4 = j4.get<std::deque<bool>>();
|
||||
auto m5 = j5.get<std::deque<std::string>>();
|
||||
}
|
||||
|
||||
TEST_F(JsonArrayConversionTest, StdSet)
|
||||
{
|
||||
auto m1 = j1.get<std::set<int>>();
|
||||
auto m2 = j2.get<std::set<unsigned int>>();
|
||||
auto m3 = j3.get<std::set<double>>();
|
||||
auto m4 = j4.get<std::set<bool>>();
|
||||
auto m5 = j5.get<std::set<std::string>>();
|
||||
}
|
||||
|
||||
TEST_F(JsonArrayConversionTest, StdUnorderedSet)
|
||||
{
|
||||
auto m1 = j1.get<std::unordered_set<int>>();
|
||||
auto m2 = j2.get<std::unordered_set<unsigned int>>();
|
||||
auto m3 = j3.get<std::unordered_set<double>>();
|
||||
auto m4 = j4.get<std::unordered_set<bool>>();
|
||||
auto m5 = j5.get<std::unordered_set<std::string>>();
|
||||
}
|
||||
|
||||
// exception in case of a non-object type
|
||||
TEST_F(JsonArrayConversionTest, Exception)
|
||||
{
|
||||
EXPECT_THROW_MSG((json().get<std::list<int>>()), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
EXPECT_THROW_MSG((json().get<std::vector<int>>()), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
EXPECT_THROW_MSG((json().get<std::vector<json>>()), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
EXPECT_THROW_MSG((json().get<std::list<json>>()), json::type_error,
|
||||
"[json.exception.type_error.302] type must be array, but is null");
|
||||
// does type really must be an array? or it rather must not be null?
|
||||
// that's what I thought when other test like this one broke
|
||||
}
|
||||
Reference in New Issue
Block a user