From 204bede84beeb292d2f8ed957b3fc427b32e05dd Mon Sep 17 00:00:00 2001 From: BlackMATov Date: Wed, 1 May 2019 12:24:30 +0700 Subject: [PATCH] json utils unit tests --- headers/enduro2d/utils/json_utils.hpp | 10 +- sources/enduro2d/utils/json_utils.cpp | 216 ++++++++--- untests/sources/untests_utils/json_utils.cpp | 385 +++++++++++++++++++ untests/sources/untests_utils/xml_utils.cpp | 11 + 4 files changed, 554 insertions(+), 68 deletions(-) create mode 100644 untests/sources/untests_utils/json_utils.cpp create mode 100644 untests/sources/untests_utils/xml_utils.cpp diff --git a/headers/enduro2d/utils/json_utils.hpp b/headers/enduro2d/utils/json_utils.hpp index c0f99283..cb373646 100644 --- a/headers/enduro2d/utils/json_utils.hpp +++ b/headers/enduro2d/utils/json_utils.hpp @@ -68,10 +68,10 @@ namespace e2d { namespace json_utils std::is_integral::value && std::is_signed::value, bool> try_parse_value(const rapidjson::Value& root, T& v) noexcept { - if ( !root.IsNumber() || !root.IsInt64() ) { + if ( !root.IsInt() ) { return false; } - const auto iv = root.GetInt64(); + const auto iv = root.GetInt(); if ( iv < std::numeric_limits::min() ) { return false; } @@ -87,10 +87,10 @@ namespace e2d { namespace json_utils std::is_integral::value && std::is_unsigned::value, bool> try_parse_value(const rapidjson::Value& root, T& v) noexcept { - if ( !root.IsNumber() || !root.IsUint64() ) { + if ( !root.IsUint() ) { return false; } - const auto uv = root.GetUint64(); + const auto uv = root.GetUint(); if ( uv < std::numeric_limits::min() ) { return false; } @@ -108,7 +108,7 @@ namespace e2d { namespace json_utils if ( !root.IsNumber() ) { return false; } - v = math::numeric_cast(root.GetDouble()); + v = math::numeric_cast(root.GetFloat()); return true; } }} diff --git a/sources/enduro2d/utils/json_utils.cpp b/sources/enduro2d/utils/json_utils.cpp index 991952b2..44cd9731 100644 --- a/sources/enduro2d/utils/json_utils.cpp +++ b/sources/enduro2d/utils/json_utils.cpp @@ -217,8 +217,11 @@ namespace template < std::size_t N, typename V, typename FV > bool parse_vN(const rapidjson::Value& root, V& v, FV&& f) noexcept { if ( root.IsNumber() ) { - v = V(f(root)); - return true; + typename V::value_type tv; + if ( f(root, tv) ) { + v = V(tv); + return true; + } } if ( root.IsObject() ) { @@ -226,10 +229,9 @@ namespace for ( std::size_t i = 0; i < math::min(N, E2D_COUNTOF(props)); ++i ) { if ( root.HasMember(props[i]) ) { const auto& jv = root[props[i]]; - if ( !jv.IsNumber() ) { + if ( !f(jv, v[i]) ) { return false; } - v[i] = f(jv); } } return true; @@ -239,10 +241,9 @@ namespace if ( root.Size() == N ) { for ( u32 i = 0; i < N; ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !f(jv, v[i]) ) { return false; } - v[i] = f(jv); } return true; } @@ -253,17 +254,23 @@ namespace template < u32 N, typename V > bool parse_vNi(const rapidjson::Value& root, V& v) noexcept { - return parse_vN(root, v, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetInt(); + return parse_vN(root, v, [](const rapidjson::Value& jv, i32& o){ + if ( !jv.IsInt() ) { + return false; + } + o = jv.GetInt(); + return true; }); } template < u32 N, typename V > bool parse_vNf(const rapidjson::Value& root, V& v) noexcept { - return parse_vN(root, v, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetFloat(); + return parse_vN(root, v, [](const rapidjson::Value& jv, f32& o){ + if ( !jv.IsNumber() ) { + return false; + } + o = jv.GetFloat(); + return true; }); } @@ -271,7 +278,7 @@ namespace // mat // - template < std::size_t N, typename V, typename FV > + template < u32 N, typename V, typename FV > bool parse_mN(const rapidjson::Value& root, V& v, FV&& f) noexcept { if ( root.IsArray() ) { if ( root.Size() == N ) { @@ -288,10 +295,9 @@ namespace for ( u32 i = 0; i < N; ++i ) { for ( u32 j = 0; j < N; ++j ) { const auto& jv = root[i * N + j]; - if ( !jv.IsNumber() ) { + if ( !f(jv, v[i][j]) ) { return false; } - v[i][j] = f(jv); } } return true; @@ -302,9 +308,12 @@ namespace template < u32 N, typename V > bool parse_mNf(const rapidjson::Value& root, V& v) noexcept { - return parse_mN(root, v, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetFloat(); + return parse_mN(root, v, [](const rapidjson::Value& jv, f32& o){ + if ( !jv.IsNumber() ) { + return false; + } + o = jv.GetFloat(); + return true; }); } @@ -319,10 +328,9 @@ namespace for ( std::size_t i = 0; i < E2D_COUNTOF(props); ++i ) { if ( root.HasMember(props[i]) ) { const auto& jv = root[props[i]]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b[i]) ) { return false; } - b[i] = f(jv); } } return true; @@ -332,10 +340,9 @@ namespace if ( root.Size() == 2 ) { for ( u32 i = 0; i < root.Size(); ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b.size[i]) ) { return false; } - b.size[i] = f(jv); } return true; } @@ -343,10 +350,9 @@ namespace if ( root.Size() == 4 ) { for ( u32 i = 0; i < root.Size(); ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b[i]) ) { return false; } - b[i] = f(jv); } return true; } @@ -357,17 +363,23 @@ namespace template < typename B > bool parse_b2i(const rapidjson::Value& root, B& b) noexcept { - return parse_b2(root, b, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetInt(); + return parse_b2(root, b, [](const rapidjson::Value& jv, i32& o){ + if ( !jv.IsInt() ) { + return false; + } + o = jv.GetInt(); + return true; }); } template < typename B > bool parse_b2f(const rapidjson::Value& root, B& b) noexcept { - return parse_b2(root, b, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetFloat(); + return parse_b2(root, b, [](const rapidjson::Value& jv, f32& o){ + if ( !jv.IsNumber() ) { + return false; + } + o = jv.GetFloat(); + return true; }); } @@ -382,10 +394,9 @@ namespace for ( std::size_t i = 0; i < E2D_COUNTOF(props); ++i ) { if ( root.HasMember(props[i]) ) { const auto& jv = root[props[i]]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b[i]) ) { return false; } - b[i] = f(jv); } } return true; @@ -395,10 +406,9 @@ namespace if ( root.Size() == 3 ) { for ( u32 i = 0; i < root.Size(); ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b.size[i]) ) { return false; } - b.size[i] = f(jv); } return true; } @@ -406,10 +416,9 @@ namespace if ( root.Size() == 6 ) { for ( u32 i = 0; i < root.Size(); ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !f(jv, b[i]) ) { return false; } - b[i] = f(jv); } return true; } @@ -420,17 +429,23 @@ namespace template < typename B > bool parse_b3i(const rapidjson::Value& root, B& b) noexcept { - return parse_b3(root, b, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetInt(); + return parse_b3(root, b, [](const rapidjson::Value& jv, i32& o){ + if ( !jv.IsInt() ) { + return false; + } + o = jv.GetInt(); + return true; }); } template < typename B > bool parse_b3f(const rapidjson::Value& root, B& b) noexcept { - return parse_b3(root, b, [](const rapidjson::Value& jv){ - E2D_ASSERT(jv.IsNumber()); - return jv.GetFloat(); + return parse_b3(root, b, [](const rapidjson::Value& jv, f32& o){ + if ( !jv.IsNumber() ) { + return false; + } + o = jv.GetFloat(); + return true; }); } @@ -480,8 +495,8 @@ namespace // bool parse_clr(const rapidjson::Value& root, color32& c) { - if ( root.IsNumber() ) { - u8 cv = math::numeric_cast(math::clamp(root.GetInt(), 0, 255)); + if ( root.IsUint() ) { + u8 cv = math::numeric_cast(math::clamp(root.GetUint(), 0u, 255u)); c = color32(cv, cv, cv, c.a); return true; } @@ -491,10 +506,10 @@ namespace for ( std::size_t i = 0; i < E2D_COUNTOF(props); ++i ) { if ( root.HasMember(props[i]) ) { const auto& jv = root[props[i]]; - if ( !jv.IsNumber() ) { + if ( !jv.IsUint() ) { return false; } - c[i] = math::numeric_cast(math::clamp(jv.GetInt(), 0, 255)); + c[i] = math::numeric_cast(math::clamp(jv.GetUint(), 0u, 255u)); } } return true; @@ -504,10 +519,10 @@ namespace if ( root.Size() == 3 || root.Size() == 4 ) { for ( u32 i = 0; i < root.Size(); ++i ) { const auto& jv = root[i]; - if ( !jv.IsNumber() ) { + if ( !jv.IsUint() ) { return false; } - c[i] = math::numeric_cast(math::clamp(jv.GetInt(), 0, 255)); + c[i] = math::numeric_cast(math::clamp(jv.GetUint(), 0u, 255u)); } return true; } @@ -532,15 +547,30 @@ namespace e2d { namespace json_utils namespace e2d { namespace json_utils { bool try_parse_value(const rapidjson::Value& root, v2i& v) noexcept { - return parse_vNi<2>(root, v); + v2i tv; + if ( !parse_vNi<2>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, v3i& v) noexcept { - return parse_vNi<3>(root, v); + v3i tv; + if ( !parse_vNi<3>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, v4i& v) noexcept { - return parse_vNi<4>(root, v); + v4i tv; + if ( !parse_vNi<4>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, v2u& v) noexcept { @@ -580,35 +610,75 @@ namespace e2d { namespace json_utils } bool try_parse_value(const rapidjson::Value& root, v2f& v) noexcept { - return parse_vNf<2>(root, v); + v2f tv; + if ( !parse_vNf<2>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, v3f& v) noexcept { - return parse_vNf<3>(root, v); + v3f tv; + if ( !parse_vNf<3>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, v4f& v) noexcept { - return parse_vNf<4>(root, v); + v4f tv; + if ( !parse_vNf<4>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, m2f& v) noexcept { - return parse_mNf<2>(root, v); + m2f tv; + if ( !parse_mNf<2>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, m3f& v) noexcept { - return parse_mNf<3>(root, v); + m3f tv; + if ( !parse_mNf<3>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, m4f& v) noexcept { - return parse_mNf<4>(root, v); + m4f tv; + if ( !parse_mNf<4>(root, tv) ) { + return false; + } + v = tv; + return true; } bool try_parse_value(const rapidjson::Value& root, b2i& b) noexcept { - return parse_b2i(root, b); + b2i tb; + if ( !parse_b2i(root, tb) ) { + return false; + } + b = tb; + return true; } bool try_parse_value(const rapidjson::Value& root, b3i& b) noexcept { - return parse_b3i(root, b); + b3i tb; + if ( !parse_b3i(root, tb) ) { + return false; + } + b = tb; + return true; } bool try_parse_value(const rapidjson::Value& root, b2u& b) noexcept { @@ -642,19 +712,39 @@ namespace e2d { namespace json_utils } bool try_parse_value(const rapidjson::Value& root, b2f& b) noexcept { - return parse_b2f(root, b); + b2f tb; + if ( !parse_b2f(root, tb) ) { + return false; + } + b = tb; + return true; } bool try_parse_value(const rapidjson::Value& root, b3f& b) noexcept { - return parse_b3f(root, b); + b3f tb; + if ( !parse_b3f(root, tb) ) { + return false; + } + b = tb; + return true; } bool try_parse_value(const rapidjson::Value& root, color& c) noexcept { - return parse_clr(root, c); + color tc; + if ( !parse_clr(root, tc) ) { + return false; + } + c = tc; + return true; } bool try_parse_value(const rapidjson::Value& root, color32& c) noexcept { - return parse_clr(root, c); + color32 tc; + if ( !parse_clr(root, tc) ) { + return false; + } + c = tc; + return true; } bool try_parse_value(const rapidjson::Value& root, str& s) noexcept { diff --git a/untests/sources/untests_utils/json_utils.cpp b/untests/sources/untests_utils/json_utils.cpp new file mode 100644 index 00000000..a7f0ec8a --- /dev/null +++ b/untests/sources/untests_utils/json_utils.cpp @@ -0,0 +1,385 @@ +/******************************************************************************* + * This file is part of the "Enduro2D" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#include "_utils.hpp" +using namespace e2d; + +namespace +{ + const char* json_source = R"json({ + "v0" : 42, + "v1" : -42, + + "v2" : { "x" : 1 }, + "v3" : { "x" : 1, "y" : 2 }, + "v4" : { "x" : 1, "y" : 2, "z" : 3 }, + "v5" : { "x" : 1, "y" : 2, "z" : 3, "w" : 4 }, + "v6" : { "x" : 1, "y" : -2, "z" : 3, "w" : -4 }, + + "v2_" : [1], + "v3_" : [1,2], + "v4_" : [1,2,3], + "v5_" : [1,2,3,4], + "v6_" : [1,-2,3,-4], + + "v0f" : 42.2, + "v5f" : { "x" : 1.1, "y" : 2.2, "z" : 3.3, "w" : 4.4 }, + + "m22" : [[1,2],[3,4]], + "m33" : [[1,2,3],[3,4,5],[5,6,7]], + "m44" : [[1,2,3,4],[3,4,5,6],[5,6,7,8],[7,8,9,0]], + + "m22_" : [1,2,3,4], + "m33_" : [1,2,3,3,4,5,5,6,7], + "m44_" : [1,2,3,4,3,4,5,6,5,6,7,8,7,8,9,0], + + "b2_0" : { "x" : 1, "w" : 2 }, + "b2_1" : { "x" : 1, "y" : 2, "w" : 3, "h" : 4 }, + "b2_2" : { "x" : 1, "y" : -2, "w" : 3, "h" : 4 }, + "b2_3" : [1,2], + "b2_4" : [1,2,3,4], + "b2_5" : [1,2,3], + + "b3_0" : { "x" : 1, "w" : 2 }, + "b3_1" : { "x" : 1, "y" : 2, "z" : 3, "w" : 4, "h" : 5, "d" : 6}, + "b3_2" : { "x" : 1, "y" : 2, "z" : 3, "w" : -4, "h" : 5, "d" : 6}, + "b3_3" : [1,2,3], + "b3_4" : [1,2,3,4,5,6], + "b3_5" : [1,2,3,4,5,6,7], + + "c0" : 0.5, + "c1" : { "r" : 0.1, "b" : 0.2 }, + "c2" : { "r" : 0.1, "g" : 0.2, "b" : 0.3, "a" : 0.4 }, + "c0_" : "hello", + "c1_" : { "r" : 0.5, "b" : {} }, + + "c32_0" : 20, + "c32_1" : { "r" : 10, "b" : 20 }, + "c32_2" : { "r" : 10, "g" : 20, "b" : 30, "a" : 40 }, + "c32_0_" : 1.2, + "c32_1_" : { "r" : 20, "b" : {} }, + + "s0" : "hello", + "s1" : 10, + "s2" : {}, + + "tt" : true, + "ff" : false, + "tt_" : 1, + "ff_" : [], + + "i" : 42, + "i_" : "4", + "u" : 42, + "u_" : -42, + "f0" : 1.2, + "f1" : 2, + "f_" : "hi", + + "vv" : [1,2,3], + "vv_" : "hello" + })json"; +} + +TEST_CASE("json_utils") { + rapidjson::Document doc; + REQUIRE_FALSE(doc.Parse(json_source).HasParseError()); + REQUIRE(doc.IsObject()); + { + bool t; + REQUIRE(json_utils::try_parse_value(doc["tt"], t)); + REQUIRE(t); + + bool f; + REQUIRE(json_utils::try_parse_value(doc["ff"], f)); + REQUIRE_FALSE(f); + + REQUIRE_FALSE(json_utils::try_parse_value(doc["tt_"], t)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["ff_"], f)); + + int i; + REQUIRE(json_utils::try_parse_value(doc["i"], i)); + REQUIRE(i == 42); + REQUIRE_FALSE(json_utils::try_parse_value(doc["i_"], i)); + + unsigned u; + REQUIRE(json_utils::try_parse_value(doc["u"], u)); + REQUIRE(u == 42); + REQUIRE_FALSE(json_utils::try_parse_value(doc["u_"], u)); + + float ff; + REQUIRE(json_utils::try_parse_value(doc["f0"], ff)); + REQUIRE(math::approximately(ff, 1.2f)); + REQUIRE(json_utils::try_parse_value(doc["f1"], ff)); + REQUIRE(math::approximately(ff, 2.f)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["f_"], ff)); + + vector vv; + REQUIRE(json_utils::try_parse_value(doc["vv"], vv)); + REQUIRE(vv == vector{1,2,3}); + REQUIRE_FALSE(json_utils::try_parse_value(doc["vv_"], vv)); + } + { + str s0; + wstr s1; + str16 s2; + str32 s3; + str_hash s4; + + REQUIRE(json_utils::try_parse_value(doc["s0"], s0)); + REQUIRE(s0 == make_utf8("hello")); + REQUIRE(json_utils::try_parse_value(doc["s0"], s1)); + REQUIRE(s1 == make_wide("hello")); + REQUIRE(json_utils::try_parse_value(doc["s0"], s2)); + REQUIRE(s2 == make_utf16("hello")); + REQUIRE(json_utils::try_parse_value(doc["s0"], s3)); + REQUIRE(s3 == make_utf32("hello")); + REQUIRE(json_utils::try_parse_value(doc["s0"], s4)); + REQUIRE(s4 == make_hash("hello")); + + REQUIRE_FALSE(json_utils::try_parse_value(doc["s1"], s0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s1"], s1)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s1"], s2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s1"], s3)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s1"], s4)); + + REQUIRE_FALSE(json_utils::try_parse_value(doc["s2"], s0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s2"], s1)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s2"], s2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s2"], s3)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["s2"], s4)); + } + { + color c0, c1, c2; + REQUIRE(json_utils::try_parse_value(doc["c0"], c0)); + REQUIRE(json_utils::try_parse_value(doc["c1"], c1)); + REQUIRE(json_utils::try_parse_value(doc["c2"], c2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["c0_"], c2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["c1_"], c2)); + REQUIRE(c0 == color(0.5f, 0.5f, 0.5f, 1.f)); + REQUIRE(c1 == color(0.1f, 1.0f, 0.2f, 1.0f)); + REQUIRE(c2 == color(0.1f, 0.2f, 0.3f, 0.4f)); + } + { + color32 c0, c1, c2; + REQUIRE(json_utils::try_parse_value(doc["c32_0"], c0)); + REQUIRE(json_utils::try_parse_value(doc["c32_1"], c1)); + REQUIRE(json_utils::try_parse_value(doc["c32_2"], c2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["c32_0_"], c2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["c32_1_"], c2)); + REQUIRE(c0 == color32(20, 20, 20, 255)); + REQUIRE(c1 == color32(10, 255, 20, 255)); + REQUIRE(c2 == color32(10, 20, 30, 40)); + } + { + b2i b0, b1; + REQUIRE(json_utils::try_parse_value(doc["b2_0"], b0)); + REQUIRE(json_utils::try_parse_value(doc["b2_1"], b1)); + REQUIRE(b0 == b2i(1,0,2,0)); + REQUIRE(b1 == b2i(1,2,3,4)); + + b2u b2; + REQUIRE(json_utils::try_parse_value(doc["b2_1"], b2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["b2_2"], b2)); + + b2u b3, b4; + REQUIRE(json_utils::try_parse_value(doc["b2_3"], b3)); + REQUIRE(json_utils::try_parse_value(doc["b2_4"], b4)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["b2_5"], b4)); + REQUIRE(b3 == b2u(0,0,1,2)); + REQUIRE(b4 == b2u(1,2,3,4)); + } + { + b3i b0, b1; + REQUIRE(json_utils::try_parse_value(doc["b3_0"], b0)); + REQUIRE(json_utils::try_parse_value(doc["b3_1"], b1)); + REQUIRE(b0 == b3i(1,0,0,2,0,0)); + REQUIRE(b1 == b3i(1,2,3,4,5,6)); + + b3u b2; + REQUIRE(json_utils::try_parse_value(doc["b3_1"], b2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["b3_2"], b2)); + + b3u b3, b4; + REQUIRE(json_utils::try_parse_value(doc["b3_3"], b3)); + REQUIRE(json_utils::try_parse_value(doc["b3_4"], b4)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["b3_5"], b4)); + REQUIRE(b3 == b3u(0,0,0,1,2,3)); + REQUIRE(b4 == b3u(1,2,3,4,5,6)); + } + { + m2f m0, m1; + REQUIRE(json_utils::try_parse_value(doc["m22"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m33"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m44"], m0)); + REQUIRE(m0 == m2f(1,2,3,4)); + REQUIRE(json_utils::try_parse_value(doc["m22_"], m1)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m33_"], m1)); + REQUIRE(m0 == m1); + } + { + m3f m0, m1; + REQUIRE(json_utils::try_parse_value(doc["m33"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m22"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m44"], m0)); + REQUIRE(m0 == m3f(1,2,3,3,4,5,5,6,7)); + REQUIRE(json_utils::try_parse_value(doc["m33_"], m1)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m22_"], m1)); + REQUIRE(m0 == m1); + } + { + m4f m0, m1; + REQUIRE(json_utils::try_parse_value(doc["m44"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m22"], m0)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m33"], m0)); + REQUIRE(m0 == m4f(1,2,3,4,3,4,5,6,5,6,7,8,7,8,9,0)); + REQUIRE(json_utils::try_parse_value(doc["m44_"], m1)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["m33_"], m1)); + REQUIRE(m0 == m1); + } + { + v2f v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v2f(42.f)); + REQUIRE(json_utils::try_parse_value(doc["v0f"], v0)); + REQUIRE(v0 == v2f(42.2f)); + REQUIRE(json_utils::try_parse_value(doc["v5f"], v0)); + REQUIRE(v0 == v2f(1.1f, 2.2f)); + } + { + v3f v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v3f(42.f)); + REQUIRE(json_utils::try_parse_value(doc["v0f"], v0)); + REQUIRE(v0 == v3f(42.2f)); + REQUIRE(json_utils::try_parse_value(doc["v5f"], v0)); + REQUIRE(v0 == v3f(1.1f, 2.2f, 3.3f)); + } + { + v4f v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v4f(42.f)); + REQUIRE(json_utils::try_parse_value(doc["v0f"], v0)); + REQUIRE(v0 == v4f(42.2f)); + REQUIRE(json_utils::try_parse_value(doc["v5f"], v0)); + REQUIRE(v0 == v4f(1.1f, 2.2f, 3.3f, 4.4f)); + } + { + v2u v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v2u(42)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v1"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v3"], v0)); + REQUIRE(v0 == v2u(1,2)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v6"], v0)); + } + { + v3u v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v3u(42)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v1"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v4"], v0)); + REQUIRE(v0 == v3u(1,2,3)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v6"], v0)); + } + { + v4u v0; + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(v0 == v4u(42)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v1"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v5"], v0)); + REQUIRE(v0 == v4u(1,2,3,4)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v6"], v0)); + } + { + v2i v0, v1, v2, v3, v4, v5, v6; + + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v1"], v1)); + REQUIRE(json_utils::try_parse_value(doc["v2"], v2)); + REQUIRE(json_utils::try_parse_value(doc["v3"], v3)); + REQUIRE(json_utils::try_parse_value(doc["v4"], v4)); + REQUIRE(json_utils::try_parse_value(doc["v5"], v5)); + REQUIRE(json_utils::try_parse_value(doc["v6"], v6)); + + REQUIRE(v0 == v2i(42)); + REQUIRE(v1 == v2i(-42)); + REQUIRE(v2 == v2i(1,0)); + REQUIRE(v3 == v2i(1,2)); + REQUIRE(v4 == v2i(1,2)); + REQUIRE(v5 == v2i(1,2)); + REQUIRE(v6 == v2i(1,-2)); + + v2i v2_, v3_, v4_, v5_, v6_; + + REQUIRE_FALSE(json_utils::try_parse_value(doc["v2_"], v2_)); + REQUIRE(json_utils::try_parse_value(doc["v3_"], v3_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v4_"], v4_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v5_"], v5_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v6_"], v6_)); + + REQUIRE(v3 == v3_); + } + { + v3i v0, v1, v2, v3, v4, v5, v6; + + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v1"], v1)); + REQUIRE(json_utils::try_parse_value(doc["v2"], v2)); + REQUIRE(json_utils::try_parse_value(doc["v3"], v3)); + REQUIRE(json_utils::try_parse_value(doc["v4"], v4)); + REQUIRE(json_utils::try_parse_value(doc["v5"], v5)); + REQUIRE(json_utils::try_parse_value(doc["v6"], v6)); + + REQUIRE(v0 == v3i(42)); + REQUIRE(v1 == v3i(-42)); + REQUIRE(v2 == v3i(1,0,0)); + REQUIRE(v3 == v3i(1,2,0)); + REQUIRE(v4 == v3i(1,2,3)); + REQUIRE(v5 == v3i(1,2,3)); + REQUIRE(v6 == v3i(1,-2,3)); + + v3i v2_, v3_, v4_, v5_, v6_; + + REQUIRE_FALSE(json_utils::try_parse_value(doc["v2_"], v2_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v3_"], v3_)); + REQUIRE(json_utils::try_parse_value(doc["v4_"], v4_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v5_"], v5_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v6_"], v6_)); + + REQUIRE(v4 == v4_); + } + { + v4i v0, v1, v2, v3, v4, v5, v6; + + REQUIRE(json_utils::try_parse_value(doc["v0"], v0)); + REQUIRE(json_utils::try_parse_value(doc["v1"], v1)); + REQUIRE(json_utils::try_parse_value(doc["v2"], v2)); + REQUIRE(json_utils::try_parse_value(doc["v3"], v3)); + REQUIRE(json_utils::try_parse_value(doc["v4"], v4)); + REQUIRE(json_utils::try_parse_value(doc["v5"], v5)); + REQUIRE(json_utils::try_parse_value(doc["v6"], v6)); + + REQUIRE(v0 == v4i(42)); + REQUIRE(v1 == v4i(-42)); + REQUIRE(v2 == v4i(1,0,0,0)); + REQUIRE(v3 == v4i(1,2,0,0)); + REQUIRE(v4 == v4i(1,2,3,0)); + REQUIRE(v5 == v4i(1,2,3,4)); + REQUIRE(v6 == v4i(1,-2,3,-4)); + + v4i v2_, v3_, v4_, v5_, v6_; + + REQUIRE_FALSE(json_utils::try_parse_value(doc["v2_"], v2_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v3_"], v3_)); + REQUIRE_FALSE(json_utils::try_parse_value(doc["v4_"], v4_)); + REQUIRE(json_utils::try_parse_value(doc["v5_"], v5_)); + REQUIRE(json_utils::try_parse_value(doc["v6_"], v6_)); + + REQUIRE(v5 == v5_); + REQUIRE(v6 == v6_); + } +} diff --git a/untests/sources/untests_utils/xml_utils.cpp b/untests/sources/untests_utils/xml_utils.cpp new file mode 100644 index 00000000..8402d04e --- /dev/null +++ b/untests/sources/untests_utils/xml_utils.cpp @@ -0,0 +1,11 @@ +/******************************************************************************* + * This file is part of the "Enduro2D" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#include "_utils.hpp" +using namespace e2d; + +TEST_CASE("xml_utils") { +}