From aa7e9de22cf5e25eb5353eb98500f69a3f76d141 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Thu, 1 May 2025 02:21:51 +0100 Subject: Fix all warnings in test/ --- test/test-persistence.cpp | 369 +++++++++++++++++++++++----------------------- 1 file changed, 186 insertions(+), 183 deletions(-) (limited to 'test/test-persistence.cpp') diff --git a/test/test-persistence.cpp b/test/test-persistence.cpp index ce53f72..1385424 100644 --- a/test/test-persistence.cpp +++ b/test/test-persistence.cpp @@ -15,191 +15,193 @@ #include #include -struct JPP { - template - T - load_json(const std::filesystem::path & path) - { - BOOST_TEST_CONTEXT(path) { - std::ifstream ss {path}; - auto to = Persistence::JsonParsePersistence {}.loadState(ss); - BOOST_REQUIRE(to); - return to; +namespace { + struct JPP { + template + T + loadJson(const std::filesystem::path & path) + { + BOOST_TEST_CONTEXT(path) { + std::ifstream inputStream {path}; + auto object = Persistence::JsonParsePersistence {}.loadState(inputStream); + BOOST_REQUIRE(object); + return object; + } + + // Presumably BOOST_TEST_CONTEXT is implemented as an if (...) { } + std::unreachable(); } + }; - // Presumably BOOST_TEST_CONTEXT is implemented as an if (...) { } - throw std::logic_error("We shouldn't ever get here, but apparently we can!"); + std::vector + fixturesIn(const std::filesystem::path & root) + { + return {std::filesystem::directory_iterator {root}, {}}; } -}; - -BOOST_FIXTURE_TEST_CASE(load_object, JPP) -{ - auto to = load_json>(FIXTURESDIR "json/load_object.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_CHECK_CLOSE(to->flt, 3.14, 0.01); - BOOST_CHECK_EQUAL(to->str, "Lovely string"); - BOOST_CHECK_EQUAL(to->bl, true); - BOOST_CHECK_CLOSE(to->pos[0], 3.14, 0.01); - BOOST_CHECK_CLOSE(to->pos[1], 6.28, 0.01); - BOOST_CHECK_CLOSE(to->pos[2], 1.57, 0.01); - BOOST_CHECK_EQUAL(to->gpos[0], 2147483647); - BOOST_CHECK_EQUAL(to->gpos[1], 2147483646); - BOOST_CHECK_EQUAL(to->gpos[2], -2147483648); - BOOST_REQUIRE_EQUAL(to->flts.size(), 6); - BOOST_CHECK_CLOSE(to->flts[0], 3.14, 0.01); - BOOST_CHECK_CLOSE(to->flts[1], 6.28, 0.01); - BOOST_CHECK_CLOSE(to->flts[2], 1.57, 0.01); - BOOST_CHECK_CLOSE(to->flts[3], 0, 0.01); - BOOST_CHECK_CLOSE(to->flts[4], -1, 0.01); - BOOST_CHECK_CLOSE(to->flts[5], -3.14, 0.01); - BOOST_REQUIRE_EQUAL(to->poss.size(), 2); - BOOST_CHECK_CLOSE(to->poss[0][0], 3.14, 0.01); - BOOST_CHECK_CLOSE(to->poss[0][1], 6.28, 0.01); - BOOST_CHECK_CLOSE(to->poss[0][2], 1.57, 0.01); - BOOST_CHECK_CLOSE(to->poss[1][0], 0, 0.01); - BOOST_CHECK_CLOSE(to->poss[1][1], -1, 0.01); - BOOST_CHECK_CLOSE(to->poss[1][2], -3.14, 0.01); - BOOST_REQUIRE_EQUAL(to->nest.size(), 3); - BOOST_REQUIRE_EQUAL(to->nest.at(0).size(), 2); - BOOST_REQUIRE_EQUAL(to->nest.at(0).at(0).size(), 2); - BOOST_REQUIRE_EQUAL(to->nest.at(0).at(1).size(), 3); - BOOST_REQUIRE_EQUAL(to->nest.at(1).size(), 1); - BOOST_REQUIRE_EQUAL(to->nest.at(1).at(0).size(), 1); - BOOST_REQUIRE_EQUAL(to->nest.at(2).size(), 0); - BOOST_REQUIRE(to->ptr); - BOOST_CHECK_CLOSE(to->ptr->flt, 3.14, 0.01); - BOOST_CHECK_EQUAL(to->ptr->str, "Lovely string"); } -BOOST_FIXTURE_TEST_CASE(load_nested_object, JPP) +BOOST_FIXTURE_TEST_CASE(LoadObject, JPP) { - auto to = load_json>(FIXTURESDIR "json/nested.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_CHECK_EQUAL(to->flt, 1.F); - BOOST_CHECK_EQUAL(to->str, "one"); - BOOST_REQUIRE(to->ptr); - BOOST_CHECK_EQUAL(to->ptr->flt, 2.F); - BOOST_CHECK_EQUAL(to->ptr->str, "two"); - BOOST_REQUIRE(to->ptr->ptr); - BOOST_CHECK_EQUAL(to->ptr->ptr->flt, 3.F); - BOOST_CHECK_EQUAL(to->ptr->ptr->str, "three"); - BOOST_REQUIRE(to->ptr->ptr->ptr); - BOOST_CHECK_EQUAL(to->ptr->ptr->ptr->flt, 4.F); - BOOST_CHECK_EQUAL(to->ptr->ptr->ptr->str, "four"); - BOOST_REQUIRE(!to->ptr->ptr->ptr->ptr); + auto object = loadJson>(FIXTURESDIR "json/load_object.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_CHECK_CLOSE(object->flt, 3.14, 0.01); + BOOST_CHECK_EQUAL(object->str, "Lovely string"); + BOOST_CHECK_EQUAL(object->bl, true); + BOOST_CHECK_CLOSE(object->pos[0], 3.14, 0.01); + BOOST_CHECK_CLOSE(object->pos[1], 6.28, 0.01); + BOOST_CHECK_CLOSE(object->pos[2], 1.57, 0.01); + BOOST_CHECK_EQUAL(object->gpos[0], 2147483647); + BOOST_CHECK_EQUAL(object->gpos[1], 2147483646); + BOOST_CHECK_EQUAL(object->gpos[2], -2147483648); + BOOST_REQUIRE_EQUAL(object->flts.size(), 6); + BOOST_CHECK_CLOSE(object->flts[0], 3.14, 0.01); + BOOST_CHECK_CLOSE(object->flts[1], 6.28, 0.01); + BOOST_CHECK_CLOSE(object->flts[2], 1.57, 0.01); + BOOST_CHECK_CLOSE(object->flts[3], 0, 0.01); + BOOST_CHECK_CLOSE(object->flts[4], -1, 0.01); + BOOST_CHECK_CLOSE(object->flts[5], -3.14, 0.01); + BOOST_REQUIRE_EQUAL(object->poss.size(), 2); + BOOST_CHECK_CLOSE(object->poss[0][0], 3.14, 0.01); + BOOST_CHECK_CLOSE(object->poss[0][1], 6.28, 0.01); + BOOST_CHECK_CLOSE(object->poss[0][2], 1.57, 0.01); + BOOST_CHECK_CLOSE(object->poss[1][0], 0, 0.01); + BOOST_CHECK_CLOSE(object->poss[1][1], -1, 0.01); + BOOST_CHECK_CLOSE(object->poss[1][2], -3.14, 0.01); + BOOST_REQUIRE_EQUAL(object->nest.size(), 3); + BOOST_REQUIRE_EQUAL(object->nest.at(0).size(), 2); + BOOST_REQUIRE_EQUAL(object->nest.at(0).at(0).size(), 2); + BOOST_REQUIRE_EQUAL(object->nest.at(0).at(1).size(), 3); + BOOST_REQUIRE_EQUAL(object->nest.at(1).size(), 1); + BOOST_REQUIRE_EQUAL(object->nest.at(1).at(0).size(), 1); + BOOST_REQUIRE_EQUAL(object->nest.at(2).size(), 0); + BOOST_REQUIRE(object->ptr); + BOOST_CHECK_CLOSE(object->ptr->flt, 3.14, 0.01); + BOOST_CHECK_EQUAL(object->ptr->str, "Lovely string"); } -BOOST_FIXTURE_TEST_CASE(load_implicit_object, JPP) +BOOST_FIXTURE_TEST_CASE(LoadNestedObject, JPP) { - auto to = load_json>(FIXTURESDIR "json/implicit.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_CHECK(to->ptr); - BOOST_CHECK_EQUAL(to->flt, 1.F); - BOOST_CHECK_EQUAL(to->ptr->str, "trigger"); - BOOST_CHECK_EQUAL(to->str, "after"); + auto object = loadJson>(FIXTURESDIR "json/nested.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_CHECK_EQUAL(object->flt, 1.F); + BOOST_CHECK_EQUAL(object->str, "one"); + BOOST_REQUIRE(object->ptr); + BOOST_CHECK_EQUAL(object->ptr->flt, 2.F); + BOOST_CHECK_EQUAL(object->ptr->str, "two"); + BOOST_REQUIRE(object->ptr->ptr); + BOOST_CHECK_EQUAL(object->ptr->ptr->flt, 3.F); + BOOST_CHECK_EQUAL(object->ptr->ptr->str, "three"); + BOOST_REQUIRE(object->ptr->ptr->ptr); + BOOST_CHECK_EQUAL(object->ptr->ptr->ptr->flt, 4.F); + BOOST_CHECK_EQUAL(object->ptr->ptr->ptr->str, "four"); + BOOST_REQUIRE(!object->ptr->ptr->ptr->ptr); } -BOOST_FIXTURE_TEST_CASE(load_empty_object, JPP) +BOOST_FIXTURE_TEST_CASE(LoadImplicitObject, JPP) { - auto to = load_json>(FIXTURESDIR "json/empty.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_CHECK_EQUAL(to->flt, 1.F); - BOOST_CHECK(to->ptr); - BOOST_CHECK_EQUAL(to->str, "after"); + auto object = loadJson>(FIXTURESDIR "json/implicit.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_CHECK(object->ptr); + BOOST_CHECK_EQUAL(object->flt, 1.F); + BOOST_CHECK_EQUAL(object->ptr->str, "trigger"); + BOOST_CHECK_EQUAL(object->str, "after"); } -static std::vector -fixtures_in(const std::filesystem::path & root) +BOOST_FIXTURE_TEST_CASE(LoadEmptyObject, JPP) { - return {std::filesystem::directory_iterator {root}, {}}; + auto object = loadJson>(FIXTURESDIR "json/empty.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_CHECK_EQUAL(object->flt, 1.F); + BOOST_CHECK(object->ptr); + BOOST_CHECK_EQUAL(object->str, "after"); } -BOOST_DATA_TEST_CASE_F(JPP, various_parse_failures, fixtures_in(FIXTURESDIR "json/bad"), path) +BOOST_DATA_TEST_CASE_F(JPP, various_parse_failures, fixturesIn(FIXTURESDIR "json/bad"), path) { - BOOST_CHECK_THROW(load_json>(path), std::runtime_error); + BOOST_CHECK_THROW(loadJson>(path), std::runtime_error); } -BOOST_FIXTURE_TEST_CASE(load_obj_no_such_type, JPP) +BOOST_FIXTURE_TEST_CASE(LoadObjNoSuchType, JPP) { - BOOST_CHECK_THROW(load_json>(FIXTURESDIR "json/bad_type.json"), std::out_of_range); + BOOST_CHECK_THROW(loadJson>(FIXTURESDIR "json/bad_type.json"), std::out_of_range); } -BOOST_FIXTURE_TEST_CASE(load_abs_object, JPP) +BOOST_FIXTURE_TEST_CASE(LoadAbsObject, JPP) { - auto to = load_json>(FIXTURESDIR "json/abs.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_REQUIRE(to->aptr); - BOOST_CHECK_NO_THROW(to->aptr->dummy()); - BOOST_CHECK_EQUAL(to->aptr->base, "set base"); - auto s = dynamic_cast(to->aptr.get()); - BOOST_REQUIRE(s); - BOOST_CHECK_EQUAL(s->sub, "set sub"); + auto object = loadJson>(FIXTURESDIR "json/abs.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_REQUIRE(object->aptr); + BOOST_CHECK_NO_THROW(object->aptr->dummy()); + BOOST_CHECK_EQUAL(object->aptr->base, "set base"); + auto subObject = dynamic_cast(object->aptr.get()); + BOOST_REQUIRE(subObject); + BOOST_CHECK_EQUAL(subObject->sub, "set sub"); } -BOOST_FIXTURE_TEST_CASE(load_vector_ptr, JPP) +BOOST_FIXTURE_TEST_CASE(LoadVectorPtr, JPP) { - auto to = load_json>(FIXTURESDIR "json/vector_ptr.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_CHECK(to->str.empty()); - BOOST_CHECK_EQUAL(to->vptr.size(), 4); - BOOST_CHECK_EQUAL(to->vptr.at(0)->str, "type"); - BOOST_CHECK_CLOSE(to->vptr.at(1)->flt, 3.14, .01); - BOOST_CHECK(!to->vptr.at(2)); - BOOST_CHECK(to->vptr.at(3)->str.empty()); + auto object = loadJson>(FIXTURESDIR "json/vector_ptr.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_CHECK(object->str.empty()); + BOOST_CHECK_EQUAL(object->vptr.size(), 4); + BOOST_CHECK_EQUAL(object->vptr.at(0)->str, "type"); + BOOST_CHECK_CLOSE(object->vptr.at(1)->flt, 3.14, .01); + BOOST_CHECK(!object->vptr.at(2)); + BOOST_CHECK(object->vptr.at(3)->str.empty()); } -BOOST_FIXTURE_TEST_CASE(test_conversion, JPP) +BOOST_FIXTURE_TEST_CASE(TestConversion, JPP) { - auto to = load_json>(FIXTURESDIR "json/conv.json"); - BOOST_CHECK_EQUAL(to->postLoadCalled, 1); - BOOST_REQUIRE(to); - BOOST_CHECK_EQUAL(to->bl, true); - BOOST_CHECK_EQUAL(to->flt, 3.14F); + auto object = loadJson>(FIXTURESDIR "json/conv.json"); + BOOST_CHECK_EQUAL(object->postLoadCalled, 1); + BOOST_REQUIRE(object); + BOOST_CHECK_EQUAL(object->bl, true); + BOOST_CHECK_EQUAL(object->flt, 3.14F); } -BOOST_FIXTURE_TEST_CASE(load_shared_object_diff, JPP) +BOOST_FIXTURE_TEST_CASE(LoadSharedObjectDiff, JPP) { - auto to = load_json>(FIXTURESDIR "json/shared_ptr_diff.json"); - BOOST_CHECK(to->sptr); - BOOST_CHECK(to->ssptr); - BOOST_CHECK_NE(to->sptr, to->ssptr); - BOOST_CHECK_EQUAL(to->sptr.use_count(), 1); - BOOST_CHECK_EQUAL(to->ssptr.use_count(), 1); + auto object = loadJson>(FIXTURESDIR "json/shared_ptr_diff.json"); + BOOST_CHECK(object->sptr); + BOOST_CHECK(object->ssptr); + BOOST_CHECK_NE(object->sptr, object->ssptr); + BOOST_CHECK_EQUAL(object->sptr.use_count(), 1); + BOOST_CHECK_EQUAL(object->ssptr.use_count(), 1); } -BOOST_FIXTURE_TEST_CASE(load_shared_object_same, JPP) +BOOST_FIXTURE_TEST_CASE(LoadSharedObjectSame, JPP) { - auto to = load_json>(FIXTURESDIR "json/shared_ptr_same.json"); - BOOST_CHECK(to->sptr); - BOOST_CHECK(to->ssptr); - BOOST_CHECK_EQUAL(to->sptr, to->ssptr); - BOOST_CHECK_EQUAL(to->sptr.use_count(), 2); - BOOST_CHECK_EQUAL(to->ssptr.use_count(), 2); + auto object = loadJson>(FIXTURESDIR "json/shared_ptr_same.json"); + BOOST_CHECK(object->sptr); + BOOST_CHECK(object->ssptr); + BOOST_CHECK_EQUAL(object->sptr, object->ssptr); + BOOST_CHECK_EQUAL(object->sptr.use_count(), 2); + BOOST_CHECK_EQUAL(object->ssptr.use_count(), 2); } -BOOST_FIXTURE_TEST_CASE(load_shared_object_diff_default, JPP) +BOOST_FIXTURE_TEST_CASE(LoadSharedObjectDiffDefault, JPP) { - auto to = load_json>(FIXTURESDIR "json/shared_ptr_diff_default.json"); - BOOST_CHECK(to->sptr); - BOOST_CHECK(to->ssptr); - BOOST_CHECK_NE(to->sptr, to->ssptr); + auto object = loadJson>(FIXTURESDIR "json/shared_ptr_diff_default.json"); + BOOST_CHECK(object->sptr); + BOOST_CHECK(object->ssptr); + BOOST_CHECK_NE(object->sptr, object->ssptr); } -BOOST_FIXTURE_TEST_CASE(load_shared_object_wrong_type, JPP) +BOOST_FIXTURE_TEST_CASE(LoadSharedObjectWrongType, JPP) { - BOOST_CHECK_THROW(load_json>(FIXTURESDIR "json/shared_ptr_wrong_type.json"), + BOOST_CHECK_THROW(loadJson>(FIXTURESDIR "json/shared_ptr_wrong_type.json"), std::runtime_error); } -BOOST_FIXTURE_TEST_CASE(load_shared_object_null, JPP) +BOOST_FIXTURE_TEST_CASE(LoadSharedObjectNull, JPP) { - auto to = load_json>(FIXTURESDIR "json/shared_ptr_null.json"); - BOOST_CHECK(to->sptr); - BOOST_CHECK(!to->ssptr); + auto object = loadJson>(FIXTURESDIR "json/shared_ptr_null.json"); + BOOST_CHECK(object->sptr); + BOOST_CHECK(!object->ssptr); } -using svs = std::tuple; -auto const TEST_STRINGS = boost::unit_test::data::make({ +using InputStringAndExpected = std::tuple; +auto const TEST_STRINGS = boost::unit_test::data::make({ {R"J("")J", ""}, {R"J("non empty")J", "non empty"}, {R"J("new\nline")J", "new\nline"}, @@ -209,7 +211,7 @@ auto const TEST_STRINGS = boost::unit_test::data::make({ {R"J("form\ffeed?")J", "form\ffeed?"}, {R"J("a \u0007 bell")J", "a \a bell"}, }); -auto const TEST_STRINGS_DECODE_ONLY = boost::unit_test::data::make({ +auto const TEST_STRINGS_DECODE_ONLY = boost::unit_test::data::make({ {R"J("forward\/slash")J", "forward/slash"}, {R"J("\u00a5 yen")J", "¥ yen"}, {R"J("gbp \u00a3")J", "gbp £"}, @@ -218,93 +220,94 @@ auto const TEST_STRINGS_DECODE_ONLY = boost::unit_test::data::make({ {R"J("\u0833 SAMARITAN PUNCTUATION BAU")J", "࠳ SAMARITAN PUNCTUATION BAU"}, }); -BOOST_DATA_TEST_CASE(load_strings, TEST_STRINGS + TEST_STRINGS_DECODE_ONLY, in, exp) +BOOST_DATA_TEST_CASE(LoadStrings, TEST_STRINGS + TEST_STRINGS_DECODE_ONLY, input, exp) { - std::stringstream str {in}; + std::stringstream str {input}; BOOST_CHECK_EQUAL(Persistence::JsonParsePersistence {}.loadState(str), exp); } -using cpstr = std::tuple; +using CodePointAndString = std::tuple; -BOOST_DATA_TEST_CASE(utf8_decode, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(Utf8Decode, + boost::unit_test::data::make({ {9, "\t"}, {0x00010000, "𐀀"}, }), - cp, str) + codePoint, str) { std::string out; - BOOST_CHECK_NO_THROW(json::jsonParser::appendEscape(cp, out)); + BOOST_CHECK_NO_THROW(json::jsonParser::appendEscape(codePoint, out)); BOOST_CHECK_EQUAL(out, str); } -BOOST_DATA_TEST_CASE(utf8_decode_bad, boost::unit_test::data::make({0xd800, 0xdfff, 0x110000}), cp) +BOOST_DATA_TEST_CASE(Utf8DecodeBad, boost::unit_test::data::make({0xd800, 0xdfff, 0x110000}), codePoint) { std::string out; - BOOST_CHECK_THROW(json::jsonParser::appendEscape(cp, out), std::runtime_error); + BOOST_CHECK_THROW(json::jsonParser::appendEscape(codePoint, out), std::runtime_error); } -BOOST_AUTO_TEST_CASE(write_test_null) +BOOST_AUTO_TEST_CASE(WriteTestNull) { - std::unique_ptr to {}; - std::stringstream ss; - Persistence::JsonWritePersistence {ss}.saveState(to); - BOOST_CHECK_EQUAL(ss.str(), "null"); + std::unique_ptr object {}; + std::stringstream outStream; + Persistence::JsonWritePersistence {outStream}.saveState(object); + BOOST_CHECK_EQUAL(outStream.view(), "null"); } -BOOST_AUTO_TEST_CASE(write_test_dfl) +BOOST_AUTO_TEST_CASE(WriteTestDfl) { - auto to = std::make_unique(); - std::stringstream ss; - Persistence::JsonWritePersistence {ss}.saveState(to); - BOOST_CHECK_EQUAL(ss.str(), + auto object = std::make_unique(); + std::stringstream outStream; + Persistence::JsonWritePersistence {outStream}.saveState(object); + BOOST_CHECK_EQUAL(outStream.view(), R"({"p.typeid":"TestObject","flt":0,"str":"","bl":false,"pos":[0,0,0],"gpos":[0,0,0],"flts":[],"poss":[],"nest":[],"vptr":[]})"); } -BOOST_FIXTURE_TEST_CASE(write_test_loaded, JPP) +BOOST_FIXTURE_TEST_CASE(WriteTestLoaded, JPP) { - auto to = load_json>(FIXTURESDIR "json/load_object.json"); - std::stringstream ss; - Persistence::JsonWritePersistence {ss}.saveState(to); - BOOST_CHECK_EQUAL(ss.str(), + auto object = loadJson>(FIXTURESDIR "json/load_object.json"); + std::stringstream outStream; + Persistence::JsonWritePersistence {outStream}.saveState(object); + BOOST_CHECK_EQUAL(outStream.view(), R"({"p.typeid":"TestObject","flt":3.14,"str":"Lovely string","bl":true,"pos":[3.14,6.28,1.57],"gpos":[2147483647,2147483646,-2147483648],"flts":[3.14,6.28,1.57,0,-1,-3.14],"poss":[[3.14,6.28,1.57],[0,-1,-3.14]],"nest":[[["a","b"],["c","d","e"]],[["f"]],[]],"ptr":{"p.typeid":"TestObject","flt":3.14,"str":"Lovely string","bl":false,"pos":[0,0,0],"gpos":[0,0,0],"flts":[],"poss":[],"nest":[],"vptr":[]},"vptr":[]})"); } -BOOST_FIXTURE_TEST_CASE(write_test_loaded_abs, JPP) +BOOST_FIXTURE_TEST_CASE(WriteTestLoadedAbs, JPP) { - auto to = load_json>(FIXTURESDIR "json/abs.json"); - std::stringstream ss; - Persistence::JsonWritePersistence {ss}.saveState(to); - BOOST_CHECK_EQUAL(ss.str(), + auto object = loadJson>(FIXTURESDIR "json/abs.json"); + std::stringstream outStream; + Persistence::JsonWritePersistence {outStream}.saveState(object); + BOOST_CHECK_EQUAL(outStream.view(), R"({"p.typeid":"TestObject","flt":0,"str":"","bl":false,"pos":[0,0,0],"gpos":[0,0,0],"flts":[],"poss":[],"nest":[],"aptr":{"p.typeid":"SubObject","base":"set base","sub":"set sub"},"vptr":[]})"); } -BOOST_FIXTURE_TEST_CASE(write_test_loaded_shared, JPP) +BOOST_FIXTURE_TEST_CASE(WriteTestLoadedShared, JPP) { - auto to = load_json>(FIXTURESDIR "json/shared_ptr_same.json"); - std::stringstream ss; + auto object = loadJson>(FIXTURESDIR "json/shared_ptr_same.json"); + std::stringstream outStream; Persistence::seenSharedObjects.clear(); - Persistence::JsonWritePersistence {ss}.saveState(to); + Persistence::JsonWritePersistence {outStream}.saveState(object); BOOST_CHECK_EQUAL(Persistence::seenSharedObjects.size(), 1); - BOOST_CHECK_EQUAL(ss.str(), + BOOST_CHECK_EQUAL(outStream.view(), R"({"p.typeid":"SharedTestObject","sptr":{"p.typeid":"SubObject","p.id":"someid","base":"","sub":""},"ssptr":"someid"})"); } -BOOST_DATA_TEST_CASE(write_special_strings, TEST_STRINGS, exp, in) +BOOST_DATA_TEST_CASE(WriteSpecialStrings, TEST_STRINGS, exp, input) { - std::stringstream ss; - std::string copy(in); - Persistence::JsonWritePersistence {ss}.saveState(copy); - BOOST_CHECK_EQUAL(ss.str(), exp); + std::stringstream outStream; + std::string copy(input); + Persistence::JsonWritePersistence {outStream}.saveState(copy); + BOOST_CHECK_EQUAL(outStream.view(), exp); } -BOOST_AUTO_TEST_CASE(get_default_id) +BOOST_AUTO_TEST_CASE(GetDefaultId) { - SubObject2 so; - const auto id {so.getId()}; + SubObject2 subObject; + const auto subObjectId {subObject.getId()}; - BOOST_TEST_CONTEXT(id) { - auto ptr = std::stoul(id, nullptr, 16); - BOOST_CHECK_EQUAL(ptr, reinterpret_cast(&so)); + BOOST_TEST_CONTEXT(subObjectId) { + auto ptr = std::stoul(subObjectId, nullptr, 16); + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) + BOOST_CHECK_EQUAL(ptr, reinterpret_cast(&subObject)); } } -- cgit v1.2.3