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/.clang-tidy | 3 + test/perf-geoData.cpp | 12 +- test/perf-terrain.cpp | 2 +- test/test-assetFactory.cpp | 253 ++++++++++++------------ test/test-collection.cpp | 228 +++++++++++----------- test/test-enumDetails.cpp | 12 +- test/test-environment.cpp | 53 +++--- test/test-geoData-counts.cpp | 2 +- test/test-geoData.cpp | 151 +++++++-------- test/test-glContainer.cpp | 109 +++++------ test/test-glContextBhvr.cpp | 38 ++-- test/test-instancing.cpp | 93 ++++----- test/test-lib.cpp | 64 ++++--- test/test-maths.cpp | 338 +++++++++++++++++---------------- test/test-network.cpp | 350 +++++++++++++++++----------------- test/test-pack.cpp | 2 +- test/test-persistence.cpp | 369 ++++++++++++++++++------------------ test/test-render.cpp | 224 +++++++++++----------- test/test-static-stream_support.cpp | 8 +- test/test-text.cpp | 79 ++++---- test/test-worker.cpp | 91 +++++---- test/testHelpers.cpp | 6 + test/testHelpers.h | 30 +-- test/testRenderOutput.cpp | 2 +- test/testStructures.h | 2 +- 25 files changed, 1280 insertions(+), 1241 deletions(-) create mode 100644 test/.clang-tidy create mode 100644 test/testHelpers.cpp diff --git a/test/.clang-tidy b/test/.clang-tidy new file mode 100644 index 0000000..6e9ebae --- /dev/null +++ b/test/.clang-tidy @@ -0,0 +1,3 @@ +InheritParentConfig: true +Checks: '-readability-magic-numbers' + diff --git a/test/perf-geoData.cpp b/test/perf-geoData.cpp index 4eff357..679f19f 100644 --- a/test/perf-geoData.cpp +++ b/test/perf-geoData.cpp @@ -2,13 +2,13 @@ #include namespace { - const GeoData geoDataFixture {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")}; + const GeoData GEO_DATA_FIXTURE {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")}; void terrainFindPoint(benchmark::State & state) { for (auto loop : state) { - benchmark::DoNotOptimize(geoDataFixture.findPoint({315555000, 495556000})); + benchmark::DoNotOptimize(GEO_DATA_FIXTURE.findPoint({315555000, 495556000})); } } @@ -16,9 +16,9 @@ namespace { terrainWalk(benchmark::State & state) { const glm::vec2 point {310001000, 490000000}; - const GeoData::PointFace start {point, geoDataFixture.findPoint(point)}; + const GeoData::PointFace start {point, GEO_DATA_FIXTURE.findPoint(point)}; for (auto loop : state) { - geoDataFixture.walk(start, {319999000, 500000000}, [](auto step) { + GEO_DATA_FIXTURE.walk(start, {319999000, 500000000}, [](auto step) { benchmark::DoNotOptimize(step); }); } @@ -28,7 +28,7 @@ namespace { terrainWalkBoundary(benchmark::State & state) { for (auto loop : state) { - geoDataFixture.boundaryWalk([](auto heh) { + GEO_DATA_FIXTURE.boundaryWalk([](auto heh) { benchmark::DoNotOptimize(heh); }); } @@ -43,7 +43,7 @@ namespace { {315655000, 495557000, 0}, }}; for (auto loop : state) { - auto geoData {geoDataFixture}; + auto geoData {GEO_DATA_FIXTURE}; benchmark::DoNotOptimize(geoData.setHeights(points, GeoData::SetHeightsOpts {.surface = nullptr})); } } diff --git a/test/perf-terrain.cpp b/test/perf-terrain.cpp index 004e1af..ed6a200 100644 --- a/test/perf-terrain.cpp +++ b/test/perf-terrain.cpp @@ -5,7 +5,7 @@ #include namespace { - const TestMainWindowAppBase window; + const TestMainWindowAppBase WINDOW; void terrainMeshgen(benchmark::State & state) diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp index 68ce6a6..ac7e04c 100644 --- a/test/test-assetFactory.cpp +++ b/test/test-assetFactory.cpp @@ -19,70 +19,75 @@ #include "gfx/renderable.h" #include "lib/collection.h" #include "lib/location.h" -#include "lib/stream_support.h" +#include "lib/stream_support.h" // IWYU pragma: keep #include "testMainWindow.h" +#include BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); -const std::filesystem::path TMP {"/tmp"}; - -class FactoryFixture : public TestRenderOutputSize, public SceneProvider { -public: - FactoryFixture() : sceneRenderer {size, output} { } - - ~FactoryFixture() - { - auto outpath = (TMP / boost::unit_test::framework::current_test_case().full_name()).replace_extension(".tga"); - std::filesystem::create_directories(outpath.parent_path()); - Texture::save(outImage, outpath.c_str()); - } - - void - content(const SceneShader & shader, const Frustum & frustum) const override - { - shader.basic.use(Location {{0, 0, 0}, {0, 0, 0}}); - objects.apply(&Renderable::render, shader, frustum); - } - - void - lights(const SceneShader & shader) const override - { - objects.apply(&Renderable::lights, shader); - } - - void - environment(const SceneShader &, const SceneRenderer & sceneRenderer) const override - { - sceneRenderer.setAmbientLight({.4, .4, .4}); - sceneRenderer.setDirectionalLight({.6, .6, .6}, {{0.9, 0.5}}, *this); - } - - void - shadows(const ShadowMapper & mapper, const Frustum & frustum) const override - { - mapper.dynamicPoint.use(Location {{0, 0, 0}, {0, 0, 0}}); - objects.apply(&Renderable::shadows, mapper, frustum); - } - - void - render(float dist) - { - sceneRenderer.camera.setView({-dist, dist * 1.2f, dist * 1.2f}, south + east + down); - sceneRenderer.render(*this); - } - - SharedCollection objects; - -private: - SceneRenderer sceneRenderer; -}; - -BOOST_AUTO_TEST_CASE(surfaces, *boost::unit_test::timeout(5)) +namespace { + class FactoryFixture : public TestRenderOutputSize, public SceneProvider { + public: + FactoryFixture() : sceneRenderer {size, output} { } + + NO_COPY(FactoryFixture); + NO_MOVE(FactoryFixture); + + ~FactoryFixture() override + { + auto outpath = (ANALYSIS_DIRECTORY / boost::unit_test::framework::current_test_case().full_name()) + .replace_extension(".tga"); + std::filesystem::create_directories(outpath.parent_path()); + Texture::save(outImage, outpath.c_str()); + } + + void + content(const SceneShader & shader, const Frustum & frustum) const override + { + shader.basic.use(Location {.pos = {0, 0, 0}, .rot = {0, 0, 0}}); + objects.apply(&Renderable::render, shader, frustum); + } + + void + lights(const SceneShader & shader) const override + { + objects.apply(&Renderable::lights, shader); + } + + void + environment(const SceneShader &, const SceneRenderer & sceneRenderer) const override + { + sceneRenderer.setAmbientLight({.4, .4, .4}); + sceneRenderer.setDirectionalLight({.6, .6, .6}, {{0.9, 0.5}}, *this); + } + + void + shadows(const ShadowMapper & mapper, const Frustum & frustum) const override + { + mapper.dynamicPoint.use(Location {.pos = {0, 0, 0}, .rot = {0, 0, 0}}); + objects.apply(&Renderable::shadows, mapper, frustum); + } + + void + render(float dist) + { + sceneRenderer.camera.setView({-dist, dist * 1.2F, dist * 1.2F}, south + east + down); + sceneRenderer.render(*this); + } + + SharedCollection objects; + + private: + SceneRenderer sceneRenderer; + }; +} + +BOOST_AUTO_TEST_CASE(Surfaces, *boost::unit_test::timeout(5)) { - auto mf = AssetFactory::loadXML(RESDIR "/surfaces.xml"); - BOOST_REQUIRE(mf); - BOOST_CHECK_EQUAL(4, mf->assets.size()); - auto gravelAsset = mf->assets.at("terrain.surface.gravel"); + auto factory = AssetFactory::loadXML(RESDIR "/surfaces.xml"); + BOOST_REQUIRE(factory); + BOOST_CHECK_EQUAL(4, factory->assets.size()); + auto gravelAsset = factory->assets.at("terrain.surface.gravel"); BOOST_REQUIRE(gravelAsset); auto gravel = gravelAsset.dynamicCast(); BOOST_REQUIRE(gravel); @@ -93,23 +98,23 @@ BOOST_AUTO_TEST_CASE(surfaces, *boost::unit_test::timeout(5)) BOOST_FIXTURE_TEST_SUITE(m, FactoryFixture); -BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(Brush47xml, *boost::unit_test::timeout(5)) { - auto mf = AssetFactory::loadXML(RESDIR "/brush47.xml"); - BOOST_REQUIRE(mf); - gameState.assets = mf->assets; - BOOST_REQUIRE_GE(mf->shapes.size(), 6); - BOOST_CHECK(mf->shapes.at("plane")); - BOOST_CHECK(mf->shapes.at("cylinder")); - BOOST_CHECK(mf->shapes.at("cuboid")); - BOOST_CHECK(mf->shapes.at("wheel")); - BOOST_CHECK(mf->shapes.at("axel")); - auto bogie = mf->shapes.at("bogie"); + auto factory = AssetFactory::loadXML(RESDIR "/brush47.xml"); + BOOST_REQUIRE(factory); + gameState.assets = factory->assets; + BOOST_REQUIRE_GE(factory->shapes.size(), 6); + BOOST_CHECK(factory->shapes.at("plane")); + BOOST_CHECK(factory->shapes.at("cylinder")); + BOOST_CHECK(factory->shapes.at("cuboid")); + BOOST_CHECK(factory->shapes.at("wheel")); + BOOST_CHECK(factory->shapes.at("axel")); + auto bogie = factory->shapes.at("bogie"); BOOST_REQUIRE(bogie); auto bogieObj = std::dynamic_pointer_cast(bogie); BOOST_CHECK_GE(bogieObj->uses.size(), 3); - BOOST_CHECK_EQUAL(1, mf->assets.size()); - auto brush47 = mf->assets.at("brush-47"); + BOOST_CHECK_EQUAL(1, factory->assets.size()); + auto brush47 = factory->assets.at("brush-47"); BOOST_REQUIRE(brush47); auto brush47rvc = brush47.dynamicCast(); BOOST_REQUIRE(brush47rvc); @@ -123,48 +128,48 @@ BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5)) render(10000); } -BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(Tree, *boost::unit_test::timeout(5)) { - auto mf = AssetFactory::loadXML(RESDIR "/foliage.xml"); - BOOST_REQUIRE(mf); - gameState.assets = mf->assets; - auto tree_01_1 = mf->assets.at("Tree-01-1"); - BOOST_REQUIRE(tree_01_1); - auto tree_01_1_f = tree_01_1.dynamicCast(); - BOOST_REQUIRE(tree_01_1_f); - - auto plant1 = std::make_shared(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}}); - auto plant2 = std::make_shared(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}}); - auto plant3 = std::make_shared(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}}); - auto plant4 = std::make_shared(tree_01_1_f, Location {{3000, 2000, 0}, {0, 3, 0}}); - objects.emplace(tree_01_1_f); + auto factory = AssetFactory::loadXML(RESDIR "/foliage.xml"); + BOOST_REQUIRE(factory); + gameState.assets = factory->assets; + auto tree011Asset = factory->assets.at("Tree-01-1"); + BOOST_REQUIRE(tree011Asset); + auto tree011 = tree011Asset.dynamicCast(); + BOOST_REQUIRE(tree011); + + auto plant1 = std::make_shared(tree011, Location {.pos = {-2000, 2000, 0}, .rot = {0, 0, 0}}); + auto plant2 = std::make_shared(tree011, Location {.pos = {3000, -4000, 0}, .rot = {0, 1, 0}}); + auto plant3 = std::make_shared(tree011, Location {.pos = {-2000, -4000, 0}, .rot = {0, 2, 0}}); + auto plant4 = std::make_shared(tree011, Location {.pos = {3000, 2000, 0}, .rot = {0, 3, 0}}); + objects.emplace(tree011); render(6000); } -BOOST_AUTO_TEST_CASE(lights, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(Lights, *boost::unit_test::timeout(5)) { - auto mf = AssetFactory::loadXML(RESDIR "/lights.xml"); - BOOST_REQUIRE(mf); - gameState.assets = mf->assets; - auto rlight = mf->assets.at("r-light"); + auto factory = AssetFactory::loadXML(RESDIR "/lights.xml"); + BOOST_REQUIRE(factory); + gameState.assets = factory->assets; + auto rlightAsset = factory->assets.at("r-light"); + BOOST_REQUIRE(rlightAsset); + auto oldlampAsset = factory->assets.at("old-lamp"); + BOOST_REQUIRE(oldlampAsset); + auto rlight = rlightAsset.dynamicCast(); BOOST_REQUIRE(rlight); - auto oldlamp = mf->assets.at("old-lamp"); + auto oldlamp = oldlampAsset.dynamicCast(); BOOST_REQUIRE(oldlamp); - auto rlight_f = rlight.dynamicCast(); - BOOST_REQUIRE(rlight_f); - auto oldlamp_f = oldlamp.dynamicCast(); - BOOST_REQUIRE(oldlamp_f); - - auto light1 = std::make_shared(oldlamp_f, Location {{0, 0, 0}, {0, 0, 0}}); - auto light2 = std::make_shared(rlight_f, Location {{-4000, 0, 0}, {0, 2, 0}}); - auto light3 = std::make_shared(rlight_f, Location {{-4000, -4000, 0}, {0, 1, 0}}); - auto light4 = std::make_shared(oldlamp_f, Location {{3000, 4600, 0}, {0, 2, 0}}); - objects.emplace(rlight_f); - objects.emplace(oldlamp_f); + + auto light1 = std::make_shared(oldlamp, Location {.pos = {0, 0, 0}, .rot = {0, 0, 0}}); + auto light2 = std::make_shared(rlight, Location {.pos = {-4000, 0, 0}, .rot = {0, 2, 0}}); + auto light3 = std::make_shared(rlight, Location {.pos = {-4000, -4000, 0}, .rot = {0, 1, 0}}); + auto light4 = std::make_shared(oldlamp, Location {.pos = {3000, 4600, 0}, .rot = {0, 2, 0}}); + objects.emplace(rlight); + objects.emplace(oldlamp); // yes I'm hacking some floor to light up as though its a bush - auto floorf = mf->assets.at("floor").dynamicCast(); + auto floorf = factory->assets.at("floor").dynamicCast(); auto floor = std::make_shared(floorf, Location {}); objects.emplace(floorf); @@ -173,7 +178,7 @@ BOOST_AUTO_TEST_CASE(lights, *boost::unit_test::timeout(5)) BOOST_AUTO_TEST_SUITE_END(); -BOOST_AUTO_TEST_CASE(loadall) +BOOST_AUTO_TEST_CASE(Loadall) { const auto assets = AssetFactory::loadAll(RESDIR); BOOST_CHECK(assets.at("brush-47")); @@ -182,7 +187,7 @@ BOOST_AUTO_TEST_CASE(loadall) template using InOut = std::tuple; -BOOST_DATA_TEST_CASE(normalizeColourName, +BOOST_DATA_TEST_CASE(NormalizeColourName, boost::unit_test::data::make>({ {"", ""}, {"black", "black"}, @@ -194,14 +199,14 @@ BOOST_DATA_TEST_CASE(normalizeColourName, {"BlAck ", "black"}, {"Bl Ack ", "black"}, }), - in_, exp) + input, exp) { - auto in {in_}; - BOOST_CHECK_NO_THROW(AssetFactory::normalizeColourName(in)); - BOOST_CHECK_EQUAL(in, exp); + auto toNormalize {input}; + BOOST_CHECK_NO_THROW(AssetFactory::normalizeColourName(toNormalize)); + BOOST_CHECK_EQUAL(toNormalize, exp); } -BOOST_AUTO_TEST_CASE(parseX11RGB, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(ParseX11RGB, *boost::unit_test::timeout(5)) { const auto parsedColours = AssetFactory::parseX11RGB(FIXTURESDIR "rgb.txt"); BOOST_REQUIRE_EQUAL(parsedColours.size(), 20); @@ -210,7 +215,7 @@ BOOST_AUTO_TEST_CASE(parseX11RGB, *boost::unit_test::timeout(5)) BOOST_CHECK_CLOSE_VEC(parsedColours.at("lightsteelblue1"), AssetFactory::Colour(0.79, 0.88, 1)); } -BOOST_AUTO_TEST_CASE(texturePacker, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(TexturePackerSimple, *boost::unit_test::timeout(5)) { std::vector input { {10, 10}, @@ -220,28 +225,28 @@ BOOST_AUTO_TEST_CASE(texturePacker, *boost::unit_test::timeout(5)) {10, 200}, {5, 5}, }; - TexturePacker tp {input}; - BOOST_CHECK_EQUAL(TexturePacker::Size(128, 256), tp.minSize()); - const auto result = tp.pack(); + TexturePacker packer {input}; + BOOST_CHECK_EQUAL(TexturePacker::Size(128, 256), packer.minSize()); + const auto result = packer.pack(); } -BOOST_AUTO_TEST_CASE(texturePacker_many, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(TexturePackerMany, *boost::unit_test::timeout(5)) { std::vector images(256); std::fill(images.begin(), images.end(), TexturePacker::Image {32, 32}); - const auto totalSize = std::accumulate(images.begin(), images.end(), 0, [](auto t, const auto & i) { - return t + TexturePacker::area(i); + const auto totalSize = std::ranges::fold_left(images, 0, [](auto total, const auto & image) { + return total + TexturePacker::area(image); }); - TexturePacker tp {images}; - BOOST_CHECK_EQUAL(TexturePacker::Size(32, 32), tp.minSize()); - const auto result = tp.pack(); + TexturePacker packer {images}; + BOOST_CHECK_EQUAL(TexturePacker::Size(32, 32), packer.minSize()); + const auto result = packer.pack(); BOOST_CHECK_EQUAL(result.first.size(), images.size()); BOOST_CHECK_GE(TexturePacker::area(result.second), TexturePacker::area(images.front()) * static_cast(images.size())); BOOST_CHECK_EQUAL(totalSize, TexturePacker::area(result.second)); } -BOOST_AUTO_TEST_CASE(texturePacker_many_random, *boost::unit_test::timeout(15)) +BOOST_AUTO_TEST_CASE(TexturePackerManyRandom, *boost::unit_test::timeout(15)) { std::vector images(2048); std::mt19937 gen(std::random_device {}()); @@ -249,7 +254,7 @@ BOOST_AUTO_TEST_CASE(texturePacker_many_random, *boost::unit_test::timeout(15)) std::generate(images.begin(), images.end(), [&dim, &gen]() { return TexturePacker::Image {2 ^ dim(gen), 2 ^ dim(gen)}; }); - TexturePacker tp {images}; - const auto result = tp.pack(); + TexturePacker packer {images}; + const auto result = packer.pack(); BOOST_CHECK_EQUAL(result.first.size(), images.size()); } diff --git a/test/test-collection.cpp b/test/test-collection.cpp index 620d3ab..45086a9 100644 --- a/test/test-collection.cpp +++ b/test/test-collection.cpp @@ -8,50 +8,54 @@ #include #include -class Base { -public: - Base() = default; - virtual ~Base() = default; - DEFAULT_MOVE_COPY(Base); - - virtual bool - add() - { - total += 1; - return false; - } - - [[nodiscard]] virtual bool - yes() const - { - return true; - } - - unsigned int total {0}; -}; - -class Sub : public Base { -public: - bool - add() override - { - total += 2; - return true; - } -}; - -class Sub1 : public Sub { }; - -class Sub2 : public Sub { }; - -class Base2 { -public: - virtual ~Base2() = default; -}; - -class Multi : public Sub1, public Base2 { }; - -using TestCollection = SharedCollection; +namespace { + class Base { + public: + Base() = default; + virtual ~Base() = default; + DEFAULT_MOVE_COPY(Base); + + virtual bool + add() + { + total += 1; + return false; + } + + [[nodiscard]] virtual bool + yes() const + { + return true; + } + + unsigned int total {0}; + }; + + class Sub : public Base { + public: + bool + add() override + { + total += 2; + return true; + } + }; + + class Sub1 : public Sub { }; + + class Sub2 : public Sub { }; + + class Base2 { + public: + Base2() = default; + virtual ~Base2() = default; + DEFAULT_MOVE_COPY(Base2); + }; + + class Multi : public Sub1, public Base2 { }; + + using TestCollection = SharedCollection; +} BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::iterator) BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::const_iterator) @@ -61,66 +65,66 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::OtherObjects::const_iterato BOOST_FIXTURE_TEST_SUITE(tc, TestCollection) -BOOST_AUTO_TEST_CASE(empty) +BOOST_AUTO_TEST_CASE(Empty) { BOOST_CHECK(TestCollection::empty()); BOOST_REQUIRE(!apply(&Base::add)); - const auto i = applyOne(&Base::add); - BOOST_CHECK_EQUAL(i, end()); + const auto appliedTo = applyOne(&Base::add); + BOOST_CHECK_EQUAL(appliedTo, end()); BOOST_CHECK(!find()); BOOST_CHECK(!find()); BOOST_CHECK(!find()); } -BOOST_AUTO_TEST_CASE(a_base) +BOOST_AUTO_TEST_CASE(ABaseApply) { - auto b = create(); + auto base = create(); BOOST_CHECK_EQUAL(objects.size(), 1); BOOST_CHECK(std::get>(otherObjects).empty()); BOOST_REQUIRE(apply(&Base::add)); - BOOST_CHECK_EQUAL(b->total, 1); - const auto i = applyOne(&Base::add); - BOOST_CHECK_EQUAL(i, end()); - BOOST_CHECK_EQUAL(b.get(), find()); + BOOST_CHECK_EQUAL(base->total, 1); + const auto appliedTo = applyOne(&Base::add); + BOOST_CHECK_EQUAL(appliedTo, end()); + BOOST_CHECK_EQUAL(base.get(), find()); BOOST_CHECK(!find()); BOOST_CHECK(!find()); } -BOOST_AUTO_TEST_CASE(emplace_others) +BOOST_AUTO_TEST_CASE(EmplaceOthers) { - auto b = emplace(std::make_shared()); + auto base = emplace(std::make_shared()); BOOST_CHECK_EQUAL(objects.size(), 1); BOOST_CHECK(std::get>(otherObjects).empty()); - auto s = emplace(std::make_shared()); + auto sub = emplace(std::make_shared()); BOOST_CHECK_EQUAL(objects.size(), 2); BOOST_CHECK_EQUAL(std::get>(otherObjects).size(), 1); - BOOST_CHECK_EQUAL(b.get(), find()); - BOOST_CHECK_EQUAL(s.get(), find()); + BOOST_CHECK_EQUAL(base.get(), find()); + BOOST_CHECK_EQUAL(sub.get(), find()); BOOST_CHECK(!find()); } -BOOST_AUTO_TEST_CASE(a_rbase) +BOOST_AUTO_TEST_CASE(ABaseRApply) { - auto b = create(); + auto base = create(); BOOST_REQUIRE(rapply(&Base::add)); - BOOST_CHECK_EQUAL(b->total, 1); - const auto i = rapplyOne(&Base::add); - BOOST_CHECK_EQUAL(i, rend()); + BOOST_CHECK_EQUAL(base->total, 1); + const auto appliedTo = rapplyOne(&Base::add); + BOOST_CHECK_EQUAL(appliedTo, rend()); } -BOOST_AUTO_TEST_CASE(a_sub) +BOOST_AUTO_TEST_CASE(ASubApply) { - auto s = create(); + auto sub = create(); BOOST_CHECK_EQUAL(objects.size(), 1); BOOST_CHECK_EQUAL(std::get>(otherObjects).size(), 1); BOOST_REQUIRE(apply(&Base::add)); - BOOST_CHECK_EQUAL(s->total, 2); - const auto i = applyOne(&Base::add); - BOOST_CHECK_NE(i, end()); - BOOST_CHECK_EQUAL(*i, s); + BOOST_CHECK_EQUAL(sub->total, 2); + const auto appliedTo = applyOne(&Base::add); + BOOST_CHECK_NE(appliedTo, end()); + BOOST_CHECK_EQUAL(*appliedTo, sub); } -BOOST_AUTO_TEST_CASE(filter) +BOOST_AUTO_TEST_CASE(Filter) { static_assert(TestCollection::idx() == 0); static_assert(TestCollection::idx() == 0); @@ -156,7 +160,7 @@ BOOST_AUTO_TEST_CASE(filter) BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor()); } -BOOST_AUTO_TEST_CASE(begin_end) +BOOST_AUTO_TEST_CASE(BeginEnd) { BOOST_CHECK_EQUAL(0, std::distance(begin(), end())); create(); @@ -164,7 +168,7 @@ BOOST_AUTO_TEST_CASE(begin_end) BOOST_CHECK_EQUAL(2, std::distance(begin(), end())); } -BOOST_AUTO_TEST_CASE(rbegin_rend) +BOOST_AUTO_TEST_CASE(RBeginREnd) { BOOST_CHECK_EQUAL(0, std::distance(rbegin(), rend())); create(); @@ -172,23 +176,23 @@ BOOST_AUTO_TEST_CASE(rbegin_rend) BOOST_CHECK_EQUAL(2, std::distance(rbegin(), rend())); } -BOOST_AUTO_TEST_CASE(createCreate) +BOOST_AUTO_TEST_CASE(CreateCreate) { - auto b = findOrCreate(); - BOOST_CHECK(b); - auto b2 = findOrCreate(); - BOOST_CHECK_EQUAL(b, b2); - auto s = findOrCreate(); - BOOST_CHECK_NE(s, b); - auto s2 = findOrCreate(); - BOOST_CHECK_EQUAL(s, s2); + auto base1 = findOrCreate(); + BOOST_CHECK(base1); + auto base2 = findOrCreate(); + BOOST_CHECK_EQUAL(base1, base2); + auto sub1 = findOrCreate(); + BOOST_CHECK_NE(sub1, base1); + auto sub2 = findOrCreate(); + BOOST_CHECK_EQUAL(sub1, sub2); } -BOOST_AUTO_TEST_CASE(createCreateSub) +BOOST_AUTO_TEST_CASE(CreateCreateSub) { - auto s = findOrCreate(); - auto b = findOrCreate(); - BOOST_CHECK_EQUAL(s, b); + auto sub = findOrCreate(); + auto base = findOrCreate(); + BOOST_CHECK_EQUAL(sub, base); } BOOST_AUTO_TEST_SUITE_END() @@ -201,7 +205,7 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::reverse_iterator) BOOST_FIXTURE_TEST_SUITE(utc, TestUniqueCollection) -BOOST_AUTO_TEST_CASE(unique_create) +BOOST_AUTO_TEST_CASE(UniqueCreate) { create(); BOOST_CHECK_EQUAL(objects.size(), 1); @@ -211,7 +215,7 @@ BOOST_AUTO_TEST_CASE(unique_create) BOOST_CHECK_EQUAL(std::get>(otherObjects).size(), 1); } -BOOST_AUTO_TEST_CASE(move_assign) +BOOST_AUTO_TEST_CASE(MoveAssign) { create(); create(); @@ -229,7 +233,7 @@ BOOST_AUTO_TEST_CASE(move_assign) BOOST_CHECK(other.empty()); } -BOOST_AUTO_TEST_CASE(clearAll) +BOOST_AUTO_TEST_CASE(ClearAll) { create(); create(); @@ -241,7 +245,7 @@ BOOST_AUTO_TEST_CASE(clearAll) BOOST_CHECK(std::get>(otherObjects).empty()); } -BOOST_AUTO_TEST_CASE(removeAllOfSub) +BOOST_AUTO_TEST_CASE(RemoveAllOfSub) { create(); create(); @@ -258,7 +262,7 @@ BOOST_AUTO_TEST_SUITE_END() BOOST_FIXTURE_TEST_SUITE(btc, UniqueCollection) -BOOST_AUTO_TEST_CASE(no_others) +BOOST_AUTO_TEST_CASE(NoOthers) { create(); create(); @@ -266,7 +270,7 @@ BOOST_AUTO_TEST_CASE(no_others) emplace(std::make_unique()); } -BOOST_AUTO_TEST_CASE(applyAll) +BOOST_AUTO_TEST_CASE(ApplyAll) { create(); BOOST_CHECK_EQUAL(0, apply(&Base::add)); @@ -276,7 +280,7 @@ BOOST_AUTO_TEST_CASE(applyAll) BOOST_CHECK_EQUAL(2, apply(&Base::add)); } -BOOST_AUTO_TEST_CASE(applyOneType) +BOOST_AUTO_TEST_CASE(ApplyOneType) { create(); BOOST_CHECK_EQUAL(objects.end(), applyOne(&Base::yes)); @@ -294,7 +298,7 @@ using MultiCollection = Collection, Multi, Sub, Base2>; BOOST_FIXTURE_TEST_SUITE(multi, MultiCollection) -BOOST_AUTO_TEST_CASE(addMulti) +BOOST_AUTO_TEST_CASE(AddMulti) { static_assert(MultiCollection::idx() == 0); static_assert(MultiCollection::idx() == 1); @@ -326,7 +330,7 @@ BOOST_AUTO_TEST_CASE(addMulti) BOOST_CHECK_EQUAL(size(), 1); } -BOOST_AUTO_TEST_CASE(removeMulti) +BOOST_AUTO_TEST_CASE(RemoveMulti) { create(); create(); @@ -359,39 +363,39 @@ BOOST_AUTO_TEST_CASE(removeMulti) BOOST_AUTO_TEST_SUITE_END() -BOOST_AUTO_TEST_CASE(wrapped_ptr_file_cons) +BOOST_AUTO_TEST_CASE(WrappedPtrFileCons) { using FilePtr = wrapped_ptr; - const FilePtr fp {fopen, "/dev/null", "r"}; - BOOST_REQUIRE(fp); - BOOST_CHECK_NO_THROW(fflush(fp)); + const FilePtr file {fopen, "/dev/null", "r"}; + BOOST_REQUIRE(file); + BOOST_CHECK_NO_THROW(fflush(file)); - BOOST_CHECK_EQUAL(fp.get(), fp.operator->()); - BOOST_CHECK_EQUAL(fp.get(), fp.operator FILE *()); + BOOST_CHECK_EQUAL(file.get(), file.operator->()); + BOOST_CHECK_EQUAL(file.get(), file.operator FILE *()); } -BOOST_AUTO_TEST_CASE(wrapped_ptr_file_move) +BOOST_AUTO_TEST_CASE(WrappedPtrFileMove) { using FilePtr = wrapped_ptr; - FilePtr fp {fopen, "/dev/null", "r"}; - BOOST_REQUIRE(fp); + FilePtr file {fopen, "/dev/null", "r"}; + BOOST_REQUIRE(file); - FilePtr fp2 {std::move(fp)}; - BOOST_REQUIRE(!fp); + FilePtr fp2 {std::move(file)}; + BOOST_REQUIRE(!file); BOOST_REQUIRE(fp2); - fp = std::move(fp2); - BOOST_REQUIRE(fp); + file = std::move(fp2); + BOOST_REQUIRE(file); BOOST_REQUIRE(!fp2); FilePtr fp3 {fopen, "/dev/null", "r"}; - fp = std::move(fp3); + file = std::move(fp3); } -BOOST_AUTO_TEST_CASE(wrapped_ptr_file_typed) +BOOST_AUTO_TEST_CASE(WrappedPtrFileTyped) { using FilePtr = wrapped_ptrt; - const FilePtr fp {"/dev/null", "r"}; - BOOST_REQUIRE(fp); - BOOST_CHECK_NO_THROW(fflush(fp)); + const FilePtr file {"/dev/null", "r"}; + BOOST_REQUIRE(file); + BOOST_CHECK_NO_THROW(fflush(file)); } diff --git a/test/test-enumDetails.cpp b/test/test-enumDetails.cpp index 6bcd627..d4f4d2f 100644 --- a/test/test-enumDetails.cpp +++ b/test/test-enumDetails.cpp @@ -14,30 +14,30 @@ template constexpr std::array VALID_VALUES {E::Aa, E::B, E::C}; constexpr std::array INVALID_VALUES {-1, 3, 20}; #define TESTS_FOR_TYPE(TYPE) \ - BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, input) \ + BOOST_DATA_TEST_CASE(InvalidCheck##TYPE, INVALID_VALUES, input) \ { \ BOOST_CHECK(!EnumDetails::isValid(static_cast(input))); \ } \ - BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, input) \ + BOOST_DATA_TEST_CASE(InvalidParse##TYPE, INVALID_NAMES, input) \ { \ BOOST_CHECK(!EnumDetails::parse(input).has_value()); \ } \ - BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, input) \ + BOOST_DATA_TEST_CASE(InvalidToString##TYPE, INVALID_VALUES, input) \ { \ BOOST_CHECK(!EnumDetails::toString(static_cast(input)).has_value()); \ } \ - BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES, input) \ + BOOST_DATA_TEST_CASE(ValidCheck##TYPE, VALID_VALUES, input) \ { \ BOOST_CHECK(EnumDetails::isValid(input)); \ } \ - BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES, input, output) \ + BOOST_DATA_TEST_CASE(ValidParse##TYPE, VALID_NAMES ^ VALID_VALUES, input, output) \ { \ const auto parsed = EnumDetails::parse(input); \ BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ BOOST_CHECK_EQUAL(parsed.value(), output); \ } \ } \ - BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES ^ VALID_NAMES, input, output) \ + BOOST_DATA_TEST_CASE(ValidToString##TYPE, VALID_VALUES ^ VALID_NAMES, input, output) \ { \ const auto parsed = EnumDetails::toString(input); \ BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ diff --git a/test/test-environment.cpp b/test/test-environment.cpp index 8bd64be..a249192 100644 --- a/test/test-environment.cpp +++ b/test/test-environment.cpp @@ -2,7 +2,6 @@ #include "testHelpers.h" #include #include -#include #include #include @@ -11,25 +10,27 @@ #include #include -using sunPosTestData = std::tuple; -using sunDirTestData = std::tuple; -constexpr Direction2D Doncaster = {-1.1, 53.5}; -constexpr Direction2D NewYork = {74.0, 40.7}; -constexpr Direction2D Syndey = {-151.2, -33.9}; -constexpr Direction2D EqGM = {}; +namespace { + using SunPosTestData = std::tuple; + using SunDirTestData = std::tuple; + constexpr Direction2D DONCASTER = {-1.1, 53.5}; + constexpr Direction2D NEW_YORK = {74.0, 40.7}; + constexpr Direction2D SYNDEY = {-151.2, -33.9}; + constexpr Direction2D EQ_GM = {}; +} -BOOST_DATA_TEST_CASE(sun_position, - boost::unit_test::data::make({ - {EqGM, "2024-01-02T00:00:00"_time_t, {181.52F, -66.86F}}, - {EqGM, "2024-01-02T06:00:00"_time_t, {113.12F, -0.85F}}, - {EqGM, "2024-01-02T06:30:00"_time_t, {113.12F, 6.05F}}, - {EqGM, "2024-01-02T12:00:00"_time_t, {177.82F, 66.97F}}, - {EqGM, "2024-01-02T18:00:00"_time_t, {246.99F, 0.90F}}, - {EqGM, "2024-01-03T00:00:00"_time_t, {181.52F, -67.04F}}, - {EqGM, "2024-06-29T12:00:00"_time_t, {2.1F, 66.80F}}, - {Doncaster, "2024-06-29T12:00:00"_time_t, {176.34F, 59.64F}}, - {NewYork, "2024-06-29T12:00:00"_time_t, {278.04F, 27.34F}}, - {Syndey, "2024-06-29T12:00:00"_time_t, {106.13F, -63.29F}}, +BOOST_DATA_TEST_CASE(SunPosition, + boost::unit_test::data::make({ + {EQ_GM, "2024-01-02T00:00:00"_time_t, {181.52F, -66.86F}}, + {EQ_GM, "2024-01-02T06:00:00"_time_t, {113.12F, -0.85F}}, + {EQ_GM, "2024-01-02T06:30:00"_time_t, {113.12F, 6.05F}}, + {EQ_GM, "2024-01-02T12:00:00"_time_t, {177.82F, 66.97F}}, + {EQ_GM, "2024-01-02T18:00:00"_time_t, {246.99F, 0.90F}}, + {EQ_GM, "2024-01-03T00:00:00"_time_t, {181.52F, -67.04F}}, + {EQ_GM, "2024-06-29T12:00:00"_time_t, {2.1F, 66.80F}}, + {DONCASTER, "2024-06-29T12:00:00"_time_t, {176.34F, 59.64F}}, + {NEW_YORK, "2024-06-29T12:00:00"_time_t, {278.04F, 27.34F}}, + {SYNDEY, "2024-06-29T12:00:00"_time_t, {106.13F, -63.29F}}, }), position, timeOfYear, expSunPos) { @@ -38,8 +39,8 @@ BOOST_DATA_TEST_CASE(sun_position, BOOST_CHECK_CLOSE(sunPos.y, expSunPos.y, 1.F); } -BOOST_DATA_TEST_CASE(sun_direction, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(SunDirection, + boost::unit_test::data::make({ {{0.F, 0.F}, south, 0.314F, 0.0087F}, {{90.F, 0.F}, west, 0.314F, 0.0087F}, {{-90.F, 0.F}, east, 0.314F, 0.0087F}, @@ -55,9 +56,9 @@ BOOST_DATA_TEST_CASE(sun_direction, }), position, direction, amb, dir) { - const LightDirection ld {position * degreesToRads}; - BOOST_CHECK_CLOSE_VEC(ld.vector(), direction); - BOOST_CHECK_CLOSE(glm::length(ld.vector()), 1.F, 1); - BOOST_CHECK_CLOSE(ld.ambient(), amb, 5); - BOOST_CHECK_CLOSE(ld.directional(), dir, 5); + const LightDirection lightDir {position * degreesToRads}; + BOOST_CHECK_CLOSE_VEC(lightDir.vector(), direction); + BOOST_CHECK_CLOSE(glm::length(lightDir.vector()), 1.F, 1); + BOOST_CHECK_CLOSE(lightDir.ambient(), amb, 5); + BOOST_CHECK_CLOSE(lightDir.directional(), dir, 5); } diff --git a/test/test-geoData-counts.cpp b/test/test-geoData-counts.cpp index 446a68a..89f9633 100644 --- a/test/test-geoData-counts.cpp +++ b/test/test-geoData-counts.cpp @@ -11,7 +11,7 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(GeoMutation); BOOST_TEST_DECORATOR(*boost::unit_test::timeout(2)); -BOOST_DATA_TEST_CASE(deformLogical, +BOOST_DATA_TEST_CASE(DeformLogical, boost::unit_test::data::make({ {"nochange", [](GeoData &) {}, 16, 33, 18}, // No change base case {"simple", diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp index e3ef9ad..a697578 100644 --- a/test/test-geoData.cpp +++ b/test/test-geoData.cpp @@ -1,77 +1,82 @@ #define BOOST_TEST_MODULE terrain -#include "game/terrain.h" -#include "test/testMainWindow.h" -#include "test/testRenderOutput.h" #include "testHelpers.h" -#include "ui/applicationBase.h" +#include "testMainWindow.h" +#include "testRenderOutput.h" #include #include -#include #include +#include +#include + #include -class TestTerrainMesh : public GeoData { -public: - TestTerrainMesh() : GeoData {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")} { } -}; +namespace { + class TestTerrainMesh : public GeoData { + public: + TestTerrainMesh() : GeoData {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")} { } + }; -constexpr size_t ncols = 200, nrows = 200, xllcorner = 310000000, yllcorner = 490000000, cellsize = 50000; + constexpr size_t NCOLS = 200, NROWS = 200, XLLCORNER = 310000000, YLLCORNER = 490000000, CELLSIZE = 50000; + const TestTerrainMesh FIXED_TERRTAIN; +} + +BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); BOOST_FIXTURE_TEST_SUITE(ttm, TestTerrainMesh); -BOOST_AUTO_TEST_CASE(loadSuccess) +BOOST_AUTO_TEST_CASE(LoadSuccess) { - BOOST_CHECK_EQUAL(ncols * nrows, n_vertices()); - BOOST_CHECK_EQUAL(2 * (ncols - 1) * (nrows - 1), n_faces()); + BOOST_CHECK_EQUAL(NCOLS * NROWS, n_vertices()); + BOOST_CHECK_EQUAL(2 * (NCOLS - 1) * (NROWS - 1), n_faces()); const auto [lower, upper] = getExtents(); BOOST_CHECK_EQUAL(lower, GlobalPosition3D(310000000, 490000000, -2600)); BOOST_CHECK_EQUAL(upper, GlobalPosition3D(319950000, 499950000, 571600)); } -BOOST_AUTO_TEST_CASE(sanityCheck) +#ifndef NDEBUG +BOOST_AUTO_TEST_CASE(SanityCheck) { BOOST_CHECK_NO_THROW(sanityCheck()); } +#endif BOOST_AUTO_TEST_SUITE_END(); -static const TestTerrainMesh fixedTerrtain; - -BOOST_AUTO_TEST_CASE(locatePointFace) +BOOST_AUTO_TEST_CASE(LocatePointFace) { - const GeoData::PointFace pf {{310002000, 490003000}}; - BOOST_CHECK(!pf.isLocated()); - BOOST_CHECK(pf.face(&fixedTerrtain).is_valid()); - BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), 0); + const GeoData::PointFace pointFace {{310002000, 490003000}}; + BOOST_CHECK(!pointFace.isLocated()); + BOOST_CHECK(pointFace.face(&FIXED_TERRTAIN).is_valid()); + BOOST_CHECK_EQUAL(pointFace.face(&FIXED_TERRTAIN).idx(), 0); } -BOOST_AUTO_TEST_CASE(preLocatePointFace) +BOOST_AUTO_TEST_CASE(PreLocatePointFace) { - const GeoData::PointFace pf {{310002000, 490003000}, &fixedTerrtain}; - BOOST_CHECK(pf.isLocated()); - BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), 0); + const GeoData::PointFace pointFace {{310002000, 490003000}, &FIXED_TERRTAIN}; + BOOST_CHECK(pointFace.isLocated()); + BOOST_CHECK_EQUAL(pointFace.face(&FIXED_TERRTAIN).idx(), 0); } using FindPointData = std::tuple; // No boundary cases as these can produce different valid results depending on starting point -BOOST_DATA_TEST_CASE(findPointOnTerrain, +BOOST_DATA_TEST_CASE(FindPointOnTerrain, boost::unit_test::data::make({ - {{0, 0}, -1}, {{xllcorner, 0}, -1}, {{0, yllcorner}, -1}, {{xllcorner + 1, yllcorner + 2}, 0}, - {{xllcorner + (cellsize * (nrows - 1)) - 2, yllcorner + (cellsize * (ncols - 1)) - 1}, 79200}, + {{0, 0}, -1}, {{XLLCORNER, 0}, -1}, {{0, YLLCORNER}, -1}, {{XLLCORNER + 1, YLLCORNER + 2}, 0}, + {{XLLCORNER + (CELLSIZE * (NROWS - 1)) - 2, YLLCORNER + (CELLSIZE * (NCOLS - 1)) - 1}, 79200}, {{315555000, 495556000}, 44400}, // perf test target }) * boost::unit_test::data::make( {0, 1, 2, 3, 4, 5, 6, 10, 100, 150, 200, 1000, 1234, 17439, 79201, 79200, 79199}), - p, fh, start) + point, exp, start) { - BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, GeoData::FaceHandle(start)).idx()); + BOOST_CHECK_EQUAL(exp, FIXED_TERRTAIN.findPoint(point, GeoData::FaceHandle(start)).idx()); } using FindPositionData = std::tuple; -BOOST_DATA_TEST_CASE(findPositionAt, +BOOST_DATA_TEST_CASE(FindPositionAt, boost::unit_test::data::make({ // corners {{310000000, 490000000}, 32800}, @@ -86,36 +91,36 @@ BOOST_DATA_TEST_CASE(findPositionAt, // other {{310751000, 490152000}, 58326}, }), - p, h) + point, height) { - BOOST_CHECK_EQUAL(fixedTerrtain.positionAt(p), p || h); + BOOST_CHECK_EQUAL(FIXED_TERRTAIN.positionAt(point), point || height); } using FindRayIntersectData = std::tuple; -BOOST_DATA_TEST_CASE(findRayIntersect, +BOOST_DATA_TEST_CASE(FindRayIntersect, boost::unit_test::data::make({ {{310000000, 490000000, 50000}, {1, 1, -2}, {310008583, 490008583, 32834}}, {{310000000, 490000000, 50000}, {1, 1, -1}, {310017131, 490017131, 32869}}, }), - p, d, i) + point, direction, intersectionPoint) { - BOOST_CHECK_EQUAL(fixedTerrtain.intersectRay({p, d})->first, i); + BOOST_CHECK_EQUAL(FIXED_TERRTAIN.intersectRay({point, direction})->first, intersectionPoint); } -BOOST_AUTO_TEST_CASE(boundaryWalk) +BOOST_AUTO_TEST_CASE(BoundaryWalk) { size_t count {}; - fixedTerrtain.boundaryWalk([&count](auto heh) { - BOOST_CHECK(fixedTerrtain.is_boundary(heh)); + FIXED_TERRTAIN.boundaryWalk([&count](auto heh) { + BOOST_CHECK(FIXED_TERRTAIN.is_boundary(heh)); count++; }); - BOOST_CHECK_EQUAL(count, 2 * (ncols + nrows - 2)); + BOOST_CHECK_EQUAL(count, 2 * (NCOLS + NROWS - 2)); } using WalkTerrainData = std::tuple>; -BOOST_DATA_TEST_CASE(walkTerrain, +BOOST_DATA_TEST_CASE(WalkTerrain, boost::unit_test::data::make({ {{310002000, 490003000}, {310002000, 490003000}, {0}}, {{310003000, 490002000}, {310003000, 490002000}, {1}}, @@ -130,10 +135,10 @@ BOOST_DATA_TEST_CASE(walkTerrain, {{309999000, 490003000}, {310004000, 489997000}, {0, 1}}, {{310004000, 489997000}, {309999000, 490003000}, {1, 0}}, }), - from, to, visits) + fromPoint, toPoint, visits) { std::vector visited; - BOOST_CHECK_NO_THROW(fixedTerrtain.walk(from, to, [&visited](auto step) { + BOOST_CHECK_NO_THROW(FIXED_TERRTAIN.walk(fromPoint, toPoint, [&visited](auto step) { if (!visited.empty()) { BOOST_CHECK_EQUAL(step.previous.idx(), visited.back()); } @@ -142,21 +147,21 @@ BOOST_DATA_TEST_CASE(walkTerrain, BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end()); } -BOOST_DATA_TEST_CASE(walkTerrainSetsFromFace, +BOOST_DATA_TEST_CASE(WalkTerrainSetsFromFace, boost::unit_test::data::make({ {{310002000, 490003000}, {310002000, 490003000}, {0}}, {{310003000, 490002000}, {310003000, 490002000}, {1}}, {{310002000, 490003000}, {310003000, 490002000}, {0, 1}}, {{310003000, 490002000}, {310002000, 490003000}, {1, 0}}, }), - from, to, visits) + fromPoint, toPoint, visits) { - GeoData::PointFace pf {from}; - BOOST_CHECK_NO_THROW(fixedTerrtain.walk(pf, to, [](auto) { })); - BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), visits.front()); + GeoData::PointFace pointFace {fromPoint}; + BOOST_CHECK_NO_THROW(FIXED_TERRTAIN.walk(pointFace, toPoint, [](auto) { })); + BOOST_CHECK_EQUAL(pointFace.face(&FIXED_TERRTAIN).idx(), visits.front()); } -BOOST_DATA_TEST_CASE(walkTerrainUntil, +BOOST_DATA_TEST_CASE(WalkTerrainUntil, boost::unit_test::data::make({ {{310002000, 490003000}, {310002000, 490003000}, {0}}, {{310003000, 490002000}, {310003000, 490002000}, {1}}, @@ -166,10 +171,10 @@ BOOST_DATA_TEST_CASE(walkTerrainUntil, {{310202000, 490003000}, {310002000, 490003000}, {8, 7, 6, 5, 4}}, {{310002000, 490003000}, {310002000, 490203000}, {0, 399, 398, 797, 796}}, }), - from, to, visits) + fromPoint, toPoint, visits) { std::vector visited; - BOOST_CHECK_NO_THROW(fixedTerrtain.walkUntil(from, to, [&visited](const auto & step) { + BOOST_CHECK_NO_THROW(FIXED_TERRTAIN.walkUntil(fromPoint, toPoint, [&visited](const auto & step) { visited.emplace_back(step.current.idx()); return visited.size() >= 5; })); @@ -181,7 +186,7 @@ using WalkTerrainCurveData = std::tuple({ {{310002000, 490003000}, {310002000, 490003000}, {310002000, 490003000}, {0}, {}}, {{310003000, 490002000}, {310003000, 490002000}, {310003000, 490002000}, {1}, {}}, @@ -207,13 +212,13 @@ BOOST_DATA_TEST_CASE(walkTerrainCurveSetsFromFace, {311000000, 490203001}, }}, }), - from, to, centre, visits, exits) + fromPoint, toPoint, centre, visits, exits) { BOOST_REQUIRE_EQUAL(visits.size(), exits.size() + 1); std::vector visited; std::vector exited; - BOOST_CHECK_NO_THROW(fixedTerrtain.walk(from, to, centre, [&](const auto & step) { + BOOST_CHECK_NO_THROW(FIXED_TERRTAIN.walk(fromPoint, toPoint, centre, [&](const auto & step) { visited.emplace_back(step.current.idx()); BOOST_REQUIRE(!std::ranges::contains(exited, step.exitPosition)); exited.emplace_back(step.exitPosition); @@ -224,15 +229,15 @@ BOOST_DATA_TEST_CASE(walkTerrainCurveSetsFromFace, using FindEntiesData = std::tuple; -BOOST_DATA_TEST_CASE(findEntries, +BOOST_DATA_TEST_CASE(FindEntryHalfEdge, boost::unit_test::data::make({ {{307739360, 494851616}, {314056992, 500079744}, 160667}, {{308597952, 498417056}, {315154144, 504671456}, 233623}, {{302690592, 502270912}, {311585184, 497868064}, 207311}, }), - from, to, heh) + fromPoint, toPoint, heh) { - BOOST_CHECK_EQUAL(fixedTerrtain.findEntry(from, to).idx(), heh); + BOOST_CHECK_EQUAL(FIXED_TERRTAIN.findEntry(fromPoint, toPoint).idx(), heh); } using DeformTerrainData = std::tuple, @@ -240,17 +245,15 @@ using DeformTerrainData = std::tuple, BOOST_TEST_DECORATOR(*boost::unit_test::timeout(2)); -BOOST_DATA_TEST_CASE(deform, loadFixtureJson("geoData/deform/1.json"), points, cams) +BOOST_DATA_TEST_CASE(Deform, loadFixtureJson("geoData/deform/1.json"), points, cams) { Surface surface; surface.colorBias = RGB {0, 0, 1}; - ApplicationBase ab; - TestMainWindow tmw; TestRenderOutput tro {{640, 480}}; struct TestTerrain : public SceneProvider { - explicit TestTerrain(GeoData gd) : terrain(std::move(gd)) { } + explicit TestTerrain(GeoData geoData) : terrain(std::move(geoData)) { } const Terrain terrain; @@ -261,10 +264,10 @@ BOOST_DATA_TEST_CASE(deform, loadFixtureJson("geoData/deform/ } void - environment(const SceneShader &, const SceneRenderer & sr) const override + environment(const SceneShader &, const SceneRenderer & renderer) const override { - sr.setAmbientLight({0.1, 0.1, 0.1}); - sr.setDirectionalLight({1, 1, 1}, {{quarter_pi, -3 * half_pi}}, *this); + renderer.setAmbientLight({0.1, 0.1, 0.1}); + renderer.setDirectionalLight({1, 1, 1}, {{quarter_pi, -3 * half_pi}}, *this); } void @@ -279,15 +282,15 @@ BOOST_DATA_TEST_CASE(deform, loadFixtureJson("geoData/deform/ } }; - TestTerrain t {[&points, &surface]() { - auto gd = GeoData::createFlat({0, 0}, {1000000, 1000000}, 100); - BOOST_CHECK_NO_THROW(gd.setHeights(points, {.surface = &surface})); - return gd; + TestTerrain terrain {[&points, &surface]() { + auto geoData = GeoData::createFlat({0, 0}, {1000000, 1000000}, 100); + BOOST_CHECK_NO_THROW(geoData.setHeights(points, {.surface = &surface})); + return geoData; }()}; - SceneRenderer ss {tro.size, tro.output}; - std::for_each(cams.begin(), cams.end(), [&ss, &t, &tro](const auto & cam) { - ss.camera.setView(cam.first.first, glm::normalize(cam.first.second)); - BOOST_CHECK_NO_THROW(ss.render(t)); + SceneRenderer renderer {tro.size, tro.output}; + std::for_each(cams.begin(), cams.end(), [&renderer, &terrain, &tro](const auto & cam) { + renderer.camera.setView(cam.first.first, glm::normalize(cam.first.second)); + BOOST_CHECK_NO_THROW(renderer.render(terrain)); Texture::save(tro.outImage, cam.second.c_str()); }); } @@ -299,9 +302,9 @@ BOOST_DATA_TEST_CASE( { BOOST_REQUIRE(!points.empty()); Surface surface; - auto gd = std::make_shared(GeoData::createFlat({0, 0}, {1000000, 1000000}, 100)); + auto geoData = std::make_shared(GeoData::createFlat({0, 0}, {1000000, 1000000}, 100)); for (const auto & strip : points) { BOOST_REQUIRE_GE(strip.size(), 3); - BOOST_CHECK_NO_THROW(gd->setHeights(strip, {.surface = &surface, .nearNodeTolerance = 50})); + BOOST_CHECK_NO_THROW(geoData->setHeights(strip, {.surface = &surface, .nearNodeTolerance = 50})); } } diff --git a/test/test-glContainer.cpp b/test/test-glContainer.cpp index 332d440..7f82e13 100644 --- a/test/test-glContainer.cpp +++ b/test/test-glContainer.cpp @@ -18,7 +18,7 @@ BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); BOOST_FIXTURE_TEST_SUITE(i, glContainer) -BOOST_AUTO_TEST_CASE(createDestroy, *boost::unit_test::timeout(1)) +BOOST_AUTO_TEST_CASE(CreateDestroy, *boost::unit_test::timeout(1)) { // Unmapped BOOST_CHECK(!data_); @@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(createDestroy, *boost::unit_test::timeout(1)) BOOST_CHECK(!access_); } -BOOST_AUTO_TEST_CASE(mapModes) +BOOST_AUTO_TEST_CASE(MapModes) { BOOST_CHECK_EQUAL(std::accumulate(begin(), end(), 0), 0); BOOST_CHECK(!data_); @@ -78,14 +78,13 @@ BOOST_AUTO_TEST_CASE(mapModes) BOOST_CHECK_EQUAL(access_, GL_READ_WRITE); BOOST_CHECK_NO_THROW(unmap()); - const auto & c = *this; - BOOST_CHECK_EQUAL(std::accumulate(c.begin(), c.end(), 0), 10); + BOOST_CHECK_EQUAL(std::ranges::fold_left(std::as_const(*this), 0, std::plus {}), 10); BOOST_CHECK(data_); BOOST_CHECK_EQUAL(access_, GL_READ_ONLY); BOOST_CHECK_NO_THROW(unmap()); } -BOOST_AUTO_TEST_CASE(push_back_test, *boost::unit_test::timeout(1)) +BOOST_AUTO_TEST_CASE(PushBackTest, *boost::unit_test::timeout(1)) { BOOST_CHECK_EQUAL(capacity_, 1); BOOST_CHECK_EQUAL(size_, 0); @@ -103,7 +102,7 @@ BOOST_AUTO_TEST_CASE(push_back_test, *boost::unit_test::timeout(1)) } } -BOOST_AUTO_TEST_CASE(emplace_back_test, *boost::unit_test::timeout(1)) +BOOST_AUTO_TEST_CASE(EmplaceBackTest, *boost::unit_test::timeout(1)) { BOOST_CHECK_EQUAL(capacity_, 1); BOOST_CHECK_EQUAL(size_, 0); @@ -146,7 +145,7 @@ BOOST_AUTO_TEST_CASE(emplace_back_test, *boost::unit_test::timeout(1)) BOOST_CHECK_EQUAL(7, rend() - rbegin()); } -BOOST_AUTO_TEST_CASE(resize_test) +BOOST_AUTO_TEST_CASE(ResizeTest) { BOOST_CHECK_NO_THROW(push_back(1)); BOOST_CHECK_NO_THROW(emplace_back(2)); @@ -177,7 +176,7 @@ BOOST_AUTO_TEST_CASE(resize_test) BOOST_CHECK_EQUAL(rbegin(), rend()); } -BOOST_AUTO_TEST_CASE(shrink_to_fit_test) +BOOST_AUTO_TEST_CASE(ShrinkToFitTest) { BOOST_CHECK_NO_THROW(reserve(4)); BOOST_CHECK_NO_THROW(emplace_back(1)); @@ -205,7 +204,7 @@ BOOST_AUTO_TEST_CASE(shrink_to_fit_test) BOOST_CHECK_EQUAL(size(), 0); } -BOOST_AUTO_TEST_CASE(getters) +BOOST_AUTO_TEST_CASE(Getters) { BOOST_CHECK(empty()); BOOST_CHECK_NO_THROW(emplace_back(1)); @@ -238,24 +237,24 @@ BOOST_AUTO_TEST_CASE(getters) BOOST_CHECK_THROW(std::ignore = constCont.at(2), std::out_of_range); } -BOOST_AUTO_TEST_CASE(random_access) +BOOST_AUTO_TEST_CASE(RandomAccess) { BOOST_CHECK_NO_THROW(emplace_back(1)); BOOST_CHECK_NO_THROW(emplace_back(2)); BOOST_CHECK_NO_THROW(emplace_back(3)); - auto i = begin(); - BOOST_CHECK_EQUAL(1, *i); - BOOST_CHECK_EQUAL(2, *++i); - BOOST_CHECK_EQUAL(2, *i++); - BOOST_CHECK_EQUAL(3, *i); - BOOST_CHECK_EQUAL(3, *i--); - BOOST_CHECK_EQUAL(2, *i); - BOOST_CHECK_EQUAL(1, *--i); - BOOST_CHECK_EQUAL(1, *i); + auto iterator = begin(); + BOOST_CHECK_EQUAL(1, *iterator); + BOOST_CHECK_EQUAL(2, *++iterator); + BOOST_CHECK_EQUAL(2, *iterator++); + BOOST_CHECK_EQUAL(3, *iterator); + BOOST_CHECK_EQUAL(3, *iterator--); + BOOST_CHECK_EQUAL(2, *iterator); + BOOST_CHECK_EQUAL(1, *--iterator); + BOOST_CHECK_EQUAL(1, *iterator); } -BOOST_AUTO_TEST_CASE(random_write) +BOOST_AUTO_TEST_CASE(RandomWrite) { BOOST_CHECK_NO_THROW(resize(3)); BOOST_CHECK_EQUAL(size(), 3); @@ -278,7 +277,7 @@ BOOST_AUTO_TEST_CASE(random_write) BOOST_CHECK_THROW(at(4, 0), std::out_of_range); } -BOOST_AUTO_TEST_CASE(insert_remove_test) +BOOST_AUTO_TEST_CASE(InsertRemoveTest) { BOOST_CHECK_NO_THROW(emplace_back(1)); BOOST_CHECK_NO_THROW(emplace_back(2)); @@ -323,19 +322,19 @@ BOOST_AUTO_TEST_CASE(insert_remove_test) } } -BOOST_AUTO_TEST_CASE(stl) +BOOST_AUTO_TEST_CASE(StlCompatilibty) { BOOST_CHECK_NO_THROW(resize(10)); - BOOST_CHECK_NO_THROW(std::generate(begin(), end(), [x = 0]() mutable { - return x++; + BOOST_CHECK_NO_THROW(std::generate(begin(), end(), [value = 0]() mutable { + return value++; })); BOOST_CHECK_NO_THROW(std::sort(rbegin(), rend())); { std::array expected1 {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end()); } - const auto newend = std::remove_if(begin(), end(), [](const auto & x) { - return x % 2 == 0; + const auto newend = std::remove_if(begin(), end(), [](const auto & value) { + return value % 2 == 0; }); { std::array expected1 {9, 7, 5, 3, 1}; @@ -343,7 +342,7 @@ BOOST_AUTO_TEST_CASE(stl) } } -BOOST_AUTO_TEST_CASE(iter_compare) +BOOST_AUTO_TEST_CASE(IterCompare) { BOOST_CHECK_EQUAL(begin(), end()); BOOST_CHECK_EQUAL(rbegin(), rend()); @@ -356,7 +355,7 @@ BOOST_AUTO_TEST_CASE(iter_compare) BOOST_AUTO_TEST_SUITE_END(); -BOOST_AUTO_TEST_CASE(create_copy_source, *boost::unit_test::timeout(1)) +BOOST_AUTO_TEST_CASE(CreateCopySource, *boost::unit_test::timeout(1)) { const std::vector src {4, 6, 2, 4, 6, 0}; glContainer dst {src}; @@ -365,16 +364,36 @@ BOOST_AUTO_TEST_CASE(create_copy_source, *boost::unit_test::timeout(1)) BOOST_CHECK_EQUAL_COLLECTIONS(src.begin(), src.end(), dst.begin(), dst.end()); } -struct C { - int x; - float y; -}; +namespace { + struct C { + int x; + float y; + }; -static_assert(std::is_trivially_destructible_v); + static_assert(std::is_trivially_destructible_v); + + struct CC { + CC() = default; + + CC(int intValue, float floatValue) noexcept : x {intValue}, y {floatValue} { } + + ~CC() + { + ++x; + } + + DEFAULT_MOVE_COPY(CC); + + int x; + float y; + }; + + static_assert(!std::is_trivially_destructible_v); +} BOOST_FIXTURE_TEST_SUITE(c, glContainer) -BOOST_AUTO_TEST_CASE(basic) +BOOST_AUTO_TEST_CASE(Basic) { BOOST_CHECK_NO_THROW(emplace_back(1, 2.F)); BOOST_CHECK_EQUAL(1, begin()->x); @@ -391,27 +410,9 @@ BOOST_AUTO_TEST_CASE(basic) BOOST_AUTO_TEST_SUITE_END(); -struct CC { - CC() = default; - - CC(int a, float b) noexcept : x {a}, y {b} { } - - ~CC() - { - ++x; - } - - DEFAULT_MOVE_COPY(CC); - - int x; - float y; -}; - -static_assert(!std::is_trivially_destructible_v); - BOOST_FIXTURE_TEST_SUITE(cc, glContainer) -BOOST_AUTO_TEST_CASE(basic) +BOOST_AUTO_TEST_CASE(Basic) { BOOST_CHECK_NO_THROW(emplace_back(1, 2.F)); BOOST_CHECK_EQUAL(1, begin()->x); @@ -435,7 +436,7 @@ BOOST_AUTO_TEST_CASE(basic) BOOST_CHECK_EQUAL(capacity(), 1); } -BOOST_AUTO_TEST_CASE(insert_remove_test) +BOOST_AUTO_TEST_CASE(InsertRemoveTest) { BOOST_CHECK_NO_THROW(emplace_back(1, 2.F)); BOOST_CHECK_NO_THROW(emplace_back(3, 4.F)); diff --git a/test/test-glContextBhvr.cpp b/test/test-glContextBhvr.cpp index ec5cc21..e4b20e1 100644 --- a/test/test-glContextBhvr.cpp +++ b/test/test-glContextBhvr.cpp @@ -11,35 +11,39 @@ BOOST_GLOBAL_FIXTURE(ApplicationBase); #define TEST_WINDOW_PARAMS __FILE__, 0, 0, 640, 480, static_cast(SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN) -static void -CreateProgramTest() -{ - const ProgramRef p; - BOOST_REQUIRE(p); +namespace { + void + createProgramTest() + { + const ProgramRef prog; + BOOST_REQUIRE(prog); + } } -BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour1) +BOOST_AUTO_TEST_CASE(WindowContextThingsBehaviour1) { BOOST_REQUIRE(!glCreateProgram); // Init not called yet { const SDL_WindowPtr window {TEST_WINDOW_PARAMS}; BOOST_REQUIRE(window); BOOST_REQUIRE(!glCreateProgram); + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) BOOST_REQUIRE_EQUAL(gladLoadGL(reinterpret_cast(SDL_GL_GetProcAddress)), 0); // No context yet { const SDL_GLContextPtr context {window}; BOOST_REQUIRE(context); BOOST_REQUIRE(!glCreateProgram); + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) BOOST_REQUIRE_GT(gladLoadGL(reinterpret_cast(SDL_GL_GetProcAddress)), 0); BOOST_REQUIRE(glCreateProgram); - CreateProgramTest(); + createProgramTest(); } // Context destroyed BOOST_REQUIRE(glCreateProgram); // Functions still set - BOOST_REQUIRE_THROW({ const ProgramRef p; }, std::exception); // Get fails with no context + BOOST_REQUIRE_THROW({ const ProgramRef prog; }, std::exception); // Get fails with no context { const SDL_GLContextPtr context {window}; BOOST_REQUIRE(context); - CreateProgramTest(); + createProgramTest(); } } { @@ -47,11 +51,11 @@ BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour1) BOOST_REQUIRE(window); const SDL_GLContextPtr context {window}; BOOST_REQUIRE(context); - CreateProgramTest(); + createProgramTest(); } } -BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour2) +BOOST_AUTO_TEST_CASE(WindowContextThingsBehaviour2) { const SDL_WindowPtr window1 {TEST_WINDOW_PARAMS}; BOOST_REQUIRE(window1); @@ -60,12 +64,12 @@ BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour2) BOOST_REQUIRE(window2); const SDL_GLContextPtr context {window2}; BOOST_REQUIRE(context); - CreateProgramTest(); + createProgramTest(); } - BOOST_REQUIRE_THROW({ const ProgramRef p; }, std::exception); // Get fails with no context + BOOST_REQUIRE_THROW({ const ProgramRef prog; }, std::exception); // Get fails with no context } -BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour3) +BOOST_AUTO_TEST_CASE(WindowContextThingsBehaviour3) { std::optional window1 {std::in_place, TEST_WINDOW_PARAMS}; const std::optional window2 {std::in_place, TEST_WINDOW_PARAMS}; @@ -73,11 +77,11 @@ BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour3) BOOST_REQUIRE(window1.value()); const SDL_GLContextPtr context {window1.value()}; BOOST_REQUIRE(context); - CreateProgramTest(); + createProgramTest(); window1.reset(); - BOOST_REQUIRE_THROW({ const ProgramRef p; }, std::exception); // Get fails with context's window gone + BOOST_REQUIRE_THROW({ const ProgramRef prog; }, std::exception); // Get fails with context's window gone window1.emplace(TEST_WINDOW_PARAMS); BOOST_REQUIRE(window1); BOOST_REQUIRE(window1.value()); - BOOST_REQUIRE_THROW({ const ProgramRef p; }, std::exception); // Get still fails with context's window gone + BOOST_REQUIRE_THROW({ const ProgramRef prog; }, std::exception); // Get still fails with context's window gone } diff --git a/test/test-instancing.cpp b/test/test-instancing.cpp index 1dd4cea..21d78e1 100644 --- a/test/test-instancing.cpp +++ b/test/test-instancing.cpp @@ -11,36 +11,38 @@ BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); -struct TestInstanceVertices : public InstanceVertices { - void - checkReverseIndex(std::source_location ctx = std::source_location::current()) - { - BOOST_TEST_CONTEXT(ctx.function_name() << ":" << ctx.line()) { - std::vector genIndexIndex(size(), npos); - for (size_t i {}; i < index.size(); i++) { - if (index[i] != npos) { - BOOST_REQUIRE_EQUAL(genIndexIndex.at(index[i]), npos); - genIndexIndex.at(index[i]) = i; +namespace { + struct TestInstanceVertices : public InstanceVertices { + void + checkReverseIndex(std::source_location ctx = std::source_location::current()) + { + BOOST_TEST_CONTEXT(ctx.function_name() << ":" << ctx.line()) { + std::vector genIndexIndex(size(), npos); + for (size_t i {}; i < index.size(); i++) { + if (index[i] != npos) { + BOOST_REQUIRE_EQUAL(genIndexIndex.at(index[i]), npos); + genIndexIndex.at(index[i]) = i; + } } - } - BOOST_TEST_CONTEXT(reverseIndex << genIndexIndex) { - BOOST_CHECK_EQUAL_COLCOL(reverseIndex, genIndexIndex); + BOOST_TEST_CONTEXT(reverseIndex << genIndexIndex) { + BOOST_CHECK_EQUAL_COLCOL(reverseIndex, genIndexIndex); + } } } - } -}; + }; +} BOOST_FIXTURE_TEST_SUITE(i, TestInstanceVertices) -BOOST_AUTO_TEST_CASE(createDestroy) +BOOST_AUTO_TEST_CASE(CreateDestroy) { BOOST_CHECK(unused.empty()); BOOST_CHECK(index.empty()); BOOST_CHECK(reverseIndex.empty()); } -BOOST_AUTO_TEST_CASE(acquireRelease) +BOOST_AUTO_TEST_CASE(AcquireRelease) { { auto proxy = acquire(); @@ -58,7 +60,7 @@ BOOST_AUTO_TEST_CASE(acquireRelease) BOOST_CHECK(reverseIndex.empty()); } -BOOST_AUTO_TEST_CASE(acquireReleaseMove) +BOOST_AUTO_TEST_CASE(AcquireReleaseMove) { { auto proxy1 = acquire(); @@ -75,7 +77,7 @@ BOOST_AUTO_TEST_CASE(acquireReleaseMove) BOOST_CHECK(reverseIndex.empty()); } -BOOST_AUTO_TEST_CASE(autoMapUnmap) +BOOST_AUTO_TEST_CASE(AutoMapUnmap) { { auto proxy = acquire(); @@ -88,7 +90,7 @@ BOOST_AUTO_TEST_CASE(autoMapUnmap) BOOST_CHECK_EQUAL(0, size()); } -BOOST_AUTO_TEST_CASE(initialize) +BOOST_AUTO_TEST_CASE(Initialize) { auto proxy = acquire(5); const auto & constProxy = proxy; @@ -97,20 +99,20 @@ BOOST_AUTO_TEST_CASE(initialize) BOOST_CHECK_EQUAL(constProxy.get(), constProxy.get()); } -BOOST_AUTO_TEST_CASE(resize) +BOOST_AUTO_TEST_CASE(Resize) { constexpr auto COUNT = 500; std::vector proxies; std::vector expected; - for (auto n = 0; n < COUNT; n++) { - proxies.push_back(acquire(n)); - expected.emplace_back(n); + for (auto value = 0; value < COUNT; value++) { + proxies.push_back(acquire(value)); + expected.emplace_back(value); } BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), data(), data() + COUNT); BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), proxies.begin(), proxies.end()); } -BOOST_AUTO_TEST_CASE(shuffle) +BOOST_AUTO_TEST_CASE(Shuffle) { std::vector proxies; BOOST_CHECK_EQUAL(0, proxies.emplace_back(acquire(0))); @@ -176,30 +178,33 @@ BOOST_AUTO_TEST_CASE(shuffle) checkReverseIndex(); } -BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x) +BOOST_DATA_TEST_CASE(ShuffleRandom, boost::unit_test::data::xrange(0, 10), iteration) { - std::ignore = x; + std::ignore = iteration; std::mt19937 gen(std::random_device {}()); std::map::InstanceProxy> proxies; - const std::string_view actions = "aaaaaaaarararrraarrrararararaarrrarararararararararraarrrraaaarararaararar"; - int n {}; - for (const auto action : actions) { + static constexpr std::string_view ACTIONS + = "aaaaaaaarararrraarrrararararaarrrarararararararararraarrrraaaarararaararar"; + int count {}; + for (const auto action : ACTIONS) { switch (action) { + default: + std::unreachable(); case 'a': - BOOST_REQUIRE_EQUAL(n, proxies.emplace(n, acquire(n)).first->second); - n++; + BOOST_REQUIRE_EQUAL(count, proxies.emplace(count, acquire(count)).first->second); + count++; break; case 'r': BOOST_REQUIRE(!proxies.empty()); - auto e = std::next(proxies.begin(), + auto toErase = std::next(proxies.begin(), std::uniform_int_distribution<> {0, static_cast(proxies.size() - 1)}(gen)); - proxies.erase(e); + proxies.erase(toErase); break; } BOOST_REQUIRE_EQUAL(size(), proxies.size()); - for (const auto & [n, p] : proxies) { - BOOST_REQUIRE_EQUAL(n, p); + for (const auto & [value, proxy] : proxies) { + BOOST_REQUIRE_EQUAL(value, proxy); } std::set iused; for (size_t i {}; i < index.size(); i++) { @@ -219,25 +224,25 @@ BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x) } } -BOOST_AUTO_TEST_CASE(partition_by, *boost::unit_test::timeout(1)) +BOOST_AUTO_TEST_CASE(PartitionBy, *boost::unit_test::timeout(1)) { std::mt19937 gen(std::random_device {}()); std::uniform_int_distribution dist(0, 100000); - static constexpr auto N = 1000; - reserve(N); + static constexpr auto COUNT = 1000; + reserve(COUNT); std::vector instances; - instances.reserve(N); + instances.reserve(COUNT); // At least one of each instances.push_back(acquire(1)); instances.push_back(acquire(3)); - while (instances.size() < N) { + while (instances.size() < COUNT) { instances.push_back(acquire(dist(gen))); } const std::vector values(instances.begin(), instances.end()); - BOOST_REQUIRE_EQUAL(size(), N); + BOOST_REQUIRE_EQUAL(size(), COUNT); - const auto pred = [](auto x) { - return (x % 3) == 0; + const auto pred = [](auto value) { + return (value % 3) == 0; }; auto matchedEnd = partition(pred); // The underlying data is partitioned... diff --git a/test/test-lib.cpp b/test/test-lib.cpp index a1a8c80..c79ef6e 100644 --- a/test/test-lib.cpp +++ b/test/test-lib.cpp @@ -11,43 +11,45 @@ #include #include -std::set active; +namespace { + // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - tracker + std::set active; -void -generator(GLsizei n, GLuint * out) -{ - static GLuint next {1}; + void + generator(GLsizei count, GLuint * out) + { + static GLuint next {1}; - while (n--) { - active.insert(next); - *out++ = next++; + std::generate_n(out, count, []() { + return *active.emplace(next++).first; + }); } -} -void -deleter(GLsizei n, GLuint * in) -{ - BOOST_CHECK(std::all_of(in, in + n, [](GLuint id) { - return active.erase(id) > 0; - })); -} + void + deleter(GLsizei n, GLuint * input) + { + BOOST_CHECK(std::ranges::all_of(std::span(input, static_cast(n)), [](GLuint name) { + return active.erase(name) > 0; + })); + } -using TestArray = glArrays<5, &generator, &deleter>; + using TestArray = glArrays<5, &generator, &deleter>; +} -BOOST_AUTO_TEST_CASE(generate_and_delete) +BOOST_AUTO_TEST_CASE(GenerateAndDelete) { { - const TestArray a; + const TestArray arr; } BOOST_CHECK(active.empty()); } -BOOST_AUTO_TEST_CASE(generate_move_and_delete) +BOOST_AUTO_TEST_CASE(GenerateMoveAndDelete) { { - TestArray a; + TestArray arr1; BOOST_CHECK_EQUAL(TestArray::size(), active.size()); - const TestArray b {std::move(a)}; + const TestArray arr2 {std::move(arr1)}; BOOST_CHECK_EQUAL(TestArray::size(), active.size()); } BOOST_CHECK(active.empty()); @@ -56,22 +58,22 @@ BOOST_AUTO_TEST_CASE(generate_move_and_delete) constexpr std::array TRIANGLE_STRIP_IN {0, 1, 2, 3, 4, 5}; static_assert(std::distance(strip_begin(TRIANGLE_STRIP_IN), strip_end(TRIANGLE_STRIP_IN)) == 4); -BOOST_AUTO_TEST_CASE(triangle_strip_iter) +BOOST_AUTO_TEST_CASE(TriangleStripIter) { constexpr std::array TRIANGLE_STRIP_EXPECTED {0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5}; std::vector out; - std::for_each(strip_begin(TRIANGLE_STRIP_IN), strip_end(TRIANGLE_STRIP_IN), [&out](const auto & t) { - const auto [a, b, c] = t; - out.push_back(a); - out.push_back(b); - out.push_back(c); + std::for_each(strip_begin(TRIANGLE_STRIP_IN), strip_end(TRIANGLE_STRIP_IN), [&out](const auto & triangle) { + const auto [corner1, corner2, corner3] = triangle; + out.push_back(corner1); + out.push_back(corner2); + out.push_back(corner3); }); BOOST_REQUIRE_EQUAL(out.size(), (TRIANGLE_STRIP_IN.size() - 2) * 3); BOOST_CHECK_EQUAL_COLCOL(out, TRIANGLE_STRIP_EXPECTED); } -BOOST_AUTO_TEST_CASE(triangle_strip_range_adapter) +BOOST_AUTO_TEST_CASE(TriangleStripRangeAdapter) { using TriTuple = std::tuple; std::vector outRange; @@ -82,7 +84,7 @@ BOOST_AUTO_TEST_CASE(triangle_strip_range_adapter) using MergeCloseData = std::tuple, int, std::vector>; -BOOST_DATA_TEST_CASE(mergeCloseInts, +BOOST_DATA_TEST_CASE(MergeCloseInts, boost::unit_test::data::make({ {{0}, 0, {0}}, {{0, 1}, 0, {0, 1}}, @@ -112,7 +114,7 @@ BOOST_DATA_TEST_CASE(mergeCloseInts, BOOST_CHECK_EQUAL_COLCOL(mutableCollection, expected); } -BOOST_AUTO_TEST_CASE(aabb_from_points) +BOOST_AUTO_TEST_CASE(AABBFromPoints) { const auto aabb = AxisAlignedBoundingBox::fromPoints(std::vector { {1, 2, 3}, diff --git a/test/test-maths.cpp b/test/test-maths.cpp index 6f1f030..c181686 100644 --- a/test/test-maths.cpp +++ b/test/test-maths.cpp @@ -6,7 +6,6 @@ #include #include #include -#include #include #include @@ -15,8 +14,8 @@ #include #include -using vecter_and_angle = std::tuple; -using angle_pair = std::tuple; +using VecterAndAngle = std::tuple; +using AnglePair = std::tuple; // // STANDARD DEFINITIONS // @@ -48,17 +47,17 @@ static_assert(west.x < 0); // Positive rotation on the XY plane (y member, yaw, around the down axis, as would be expected for vehicle or building // on flat land) shall be clockwise, in radians. Cycles shall be considered equal; 0 == 2pi, pi == -pi, 1/4pi == -3/4pi. -BOOST_DATA_TEST_CASE(test_vector_yaw, - boost::unit_test::data::make( +BOOST_DATA_TEST_CASE(TestVectorYaw, + boost::unit_test::data::make( {{up, 0}, {north, 0}, {south, pi}, {west, -half_pi}, {east, half_pi}, {north + east, quarter_pi}, {south + east, quarter_pi * 3}, {north + west, -quarter_pi}, {south + west, -quarter_pi * 3}}), - v, a) + vec, exp) { - BOOST_CHECK_CLOSE(vector_yaw(v), a, 1.F); + BOOST_CHECK_CLOSE(vector_yaw(vec), exp, 1.F); } -BOOST_DATA_TEST_CASE(test_angle_normalize, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(TestAngleNormalize, + boost::unit_test::data::make({ {0, 0}, {two_pi, 0}, {-two_pi, 0}, @@ -67,17 +66,17 @@ BOOST_DATA_TEST_CASE(test_angle_normalize, {half_pi * 3, -half_pi}, {-half_pi * 3, half_pi}, }), - in, exp) + angle, exp) { - BOOST_CHECK_CLOSE(normalize(in), exp, 1); + BOOST_CHECK_CLOSE(normalize(angle), exp, 1); } // Positive rotation on the YZ plane (x member, pitch, around the east axis relative to its yaw, as would be expected // for a vehicle travelling forward uphill), in radians. Cycles can be considered non-sense as even in the worst/best // cases pitch beyond +/- 1/2pi would be crashing. -BOOST_DATA_TEST_CASE(test_vector_pitch, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(TestVectorPitch, + boost::unit_test::data::make({ {north, 0}, {east, 0}, {south, 0}, @@ -93,9 +92,9 @@ BOOST_DATA_TEST_CASE(test_vector_pitch, {north + west - up, -quarter_pi}, {north + west + up, quarter_pi}, }), - v, a) + vec, exp) { - BOOST_CHECK_CLOSE(vector_pitch(v), a, 1.F); + BOOST_CHECK_CLOSE(vector_pitch(vec), exp, 1.F); } // Positive rotation on the ZX plane (z member, roll, around Y axis relative to its yaw and pitch, as would be expected @@ -104,26 +103,26 @@ BOOST_DATA_TEST_CASE(test_vector_pitch, // The ILT functions rotate_yaw, rotate_pitch and rotate_roll provide a simple equivelent to glm::rotate around the // stated axis. -const auto angs = boost::unit_test::data::make({pi, half_pi, two_pi, quarter_pi, -pi, -half_pi, -quarter_pi, 0.F}) +const auto ANGLES = boost::unit_test::data::make({pi, half_pi, two_pi, quarter_pi, -pi, -half_pi, -quarter_pi, 0.F}) * boost::unit_test::data::make(0); -const auto random_angs = boost::unit_test::data::random(-two_pi, two_pi) ^ boost::unit_test::data::xrange(1000); -const auto rots = boost::unit_test::data::make>({ +const auto RANDOM_ANGLES = boost::unit_test::data::random(-two_pi, two_pi) ^ boost::unit_test::data::xrange(1000); +const auto ROTATIONS = boost::unit_test::data::make>({ {down, rotate_yaw<4>, "yaw"}, {east, rotate_pitch<4>, "pitch"}, {north, rotate_roll<4>, "roll"}, }); -BOOST_DATA_TEST_CASE(test_rotations, (angs + random_angs) * rots, angle, ai, axis, ilt_func, name) +BOOST_DATA_TEST_CASE(TestRotations, (ANGLES + RANDOM_ANGLES) * ROTATIONS, angle, index, axis, iltFunc, name) { - (void)ai; + (void)index; BOOST_TEST_CONTEXT(name) { - const auto g {glm::rotate(angle, axis)}, ilt {ilt_func(angle)}; - for (glm::length_t c = 0; c < 4; c++) { - BOOST_TEST_CONTEXT(c) { - for (glm::length_t r = 0; r < 4; r++) { - BOOST_TEST_CONTEXT(r) { - BOOST_CHECK_CLOSE(g[c][r], ilt[c][r], 0.0001); + const auto glmVal {glm::rotate(angle, axis)}, iltVal {iltFunc(angle)}; + for (glm::length_t col = 0; col < 4; col++) { + BOOST_TEST_CONTEXT(col) { + for (glm::length_t row = 0; row < 4; row++) { + BOOST_TEST_CONTEXT(row) { + BOOST_CHECK_CLOSE(glmVal[col][row], iltVal[col][row], 0.0001); } } } @@ -133,10 +132,10 @@ BOOST_DATA_TEST_CASE(test_rotations, (angs + random_angs) * rots, angle, ai, axi // An arc shall be defined as a centre point, start point and end point. The arc shall progress positively from start to // end in a clockwise manner. Arc start shall be the yaw from centre to start, arc end shall be greater than arc start. -using pos3_to_arc = std::tuple; +using Pos3ToArc = std::tuple; -BOOST_DATA_TEST_CASE(test_create_arc, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(TestCreateArc, + boost::unit_test::data::make({ {{0, 0, 0}, north, east, {0, half_pi}}, {{0, 0, 0}, west, east, {-half_pi, half_pi}}, {{0, 0, 0}, south, east, {pi, half_pi * 5}}, @@ -144,194 +143,199 @@ BOOST_DATA_TEST_CASE(test_create_arc, {{0, 0, 0}, south, north, {pi, two_pi}}, {{0, 0, 0}, east, south, {half_pi, pi}}, }), - c, s, e, a) + centre, start, end, expAngles) { - const Arc arc {c, s, e}; + const Arc arc {centre, start, end}; BOOST_REQUIRE_LT(arc.first, arc.second); - BOOST_CHECK_CLOSE(arc.first, a.first, 1.F); - BOOST_CHECK_CLOSE(arc.second, a.second, 1.F); + BOOST_CHECK_CLOSE(arc.first, expAngles.first, 1.F); + BOOST_CHECK_CLOSE(arc.second, expAngles.second, 1.F); } -using fac = std::tuple; +using FindArcCentreData = std::tuple; -BOOST_DATA_TEST_CASE(test_find_arc_centre, - boost::unit_test::data::make({ +BOOST_DATA_TEST_CASE(TestFindArcCentre, + boost::unit_test::data::make({ {{2, 2}, pi, {3, 3}, half_pi, {3, 2}, true}, {{2, 2}, pi, {1, 3}, -half_pi, {1, 2}, false}, {{-1100, -1000}, pi, {-900, -800}, half_pi, {-900, -1000}, true}, {{1100, 1000}, 0, {1050, 900}, pi + 0.92F, {973, 1000}, true}, {{1050, 900}, 0.92F, {1000, 800}, pi, {1127, 800}, false}, }), - s, es, e, ee, exp, lr) + startPoint, startEntryAngle, endPoint, endEntryAngle, expCentre, leftRight) { - const auto c = find_arc_centre(s, es, e, ee); - BOOST_CHECK_CLOSE(exp.x, c.first.x, 1); - BOOST_CHECK_CLOSE(exp.y, c.first.y, 1); - BOOST_CHECK_EQUAL(lr, c.second); + const auto centre = find_arc_centre(startPoint, startEntryAngle, endPoint, endEntryAngle); + BOOST_CHECK_CLOSE(expCentre.x, centre.first.x, 1); + BOOST_CHECK_CLOSE(expCentre.y, centre.first.y, 1); + BOOST_CHECK_EQUAL(leftRight, centre.second); } -BOOST_AUTO_TEST_CASE(test_find_arcs_radius) +BOOST_AUTO_TEST_CASE(TestFindArcsRadius) { BOOST_CHECK_CLOSE( find_arcs_radius(RelativePosition2D {10.32, 26.71}, {0.4, .92}, {2.92, 22.41}, {-0.89, -0.45}), 2.29, 1); } -struct TestLinkStraight : public LinkStraight { - explicit TestLinkStraight(glm::vec3 v) : - Link {{std::make_shared(GlobalPosition3D {}), vector_yaw(v)}, {std::make_shared(v), vector_yaw(-v)}, - glm::length(v)} +namespace { + struct TestLinkStraight : public LinkStraight { + explicit TestLinkStraight(glm::vec3 entryVector) : + Link {{.node = std::make_shared(GlobalPosition3D {}), .dir = vector_yaw(entryVector)}, + {.node = std::make_shared(entryVector), .dir = vector_yaw(-entryVector)}, + glm::length(entryVector)} + { + } + }; + + using StraightsData = std::tuple; + + struct TestLinkCurve : public LinkCurve { + explicit TestLinkCurve(glm::vec3 startPos, glm::vec3 endPos, glm::vec3 ctr) : + Link {{.node = std::make_shared(startPos), .dir = normalize(vector_yaw(ctr - startPos) - half_pi)}, + {.node = std::make_shared(endPos), .dir = normalize(vector_yaw(ctr - endPos) - half_pi)}, + glm::length(endPos - startPos)}, + LinkCurve(ctr, glm::length(startPos - ctr), {ctr, startPos, endPos}) + { + } + }; + + using CurvesData + = std::tuple; + + template + auto + nTestPointsBetween(std::size_t n = 2, T min = -100.F, T max = 100.F) { + return boost::unit_test::data::xrange(n) ^ boost::unit_test::data::random(min, max); } -}; - -using StraightsData = std::tuple; +} -BOOST_DATA_TEST_CASE(straight1, +BOOST_DATA_TEST_CASE(Straight1, boost::unit_test::data::make({ {north, 0, pi}, {south, pi, 0}, {east, half_pi, -half_pi}, {west, -half_pi, half_pi}, }), - v, angFor, angBack) + direction, angFor, angBack) { - const TestLinkStraight l(v); + const TestLinkStraight link(direction); { - const auto p = l.positionAt(0, 0); - BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {}); - BOOST_CHECK_EQUAL(p.rot, glm::vec3(0, angFor, 0)); + const auto position = link.positionAt(0, 0); + BOOST_CHECK_EQUAL(position.pos, GlobalPosition3D {}); + BOOST_CHECK_EQUAL(position.rot, glm::vec3(0, angFor, 0)); } { - const auto p = l.positionAt(0, 1); - BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {v}); - BOOST_CHECK_EQUAL(p.rot, glm::vec3(0, angBack, 0)); + const auto position = link.positionAt(0, 1); + BOOST_CHECK_EQUAL(position.pos, GlobalPosition3D {direction}); + BOOST_CHECK_EQUAL(position.rot, glm::vec3(0, angBack, 0)); } } -struct TestLinkCurve : public LinkCurve { - explicit TestLinkCurve(glm::vec3 e0, glm::vec3 e1, glm::vec3 ctr) : - Link {{std::make_shared(e0), normalize(vector_yaw(ctr - e0) - half_pi)}, - {std::make_shared(e1), normalize(vector_yaw(ctr - e1) - half_pi)}, glm::length(e1 - e0)}, - LinkCurve(ctr, glm::length(e0 - ctr), {ctr, e0, e1}) - { - } -}; - -using CurvesData = std::tuple; - -BOOST_DATA_TEST_CASE(curve1, +BOOST_DATA_TEST_CASE(Curve1, boost::unit_test::data::make({ {north + east, east, 0, -half_pi}, {east * 2.F, east, 0, 0}, {south + east, east, 0, half_pi}, {south + west, west, pi, half_pi}, }), - e1, ctr, angFor, angBack) + endPos, ctr, angFor, angBack) { { // One-way... - const TestLinkCurve l({}, e1, ctr); - BOOST_CHECK_EQUAL(l.radius, 1.F); + const TestLinkCurve link({}, endPos, ctr); + BOOST_CHECK_EQUAL(link.radius, 1.F); { - const auto p = l.positionAt(0, 0); - BOOST_CHECK_CLOSE_VECI(p.pos, GlobalPosition3D {}); - BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angFor, 0)); + const auto position = link.positionAt(0, 0); + BOOST_CHECK_CLOSE_VECI(position.pos, GlobalPosition3D {}); + BOOST_CHECK_CLOSE_VEC(position.rot, glm::vec3(0, angFor, 0)); } { - const auto p = l.positionAt(0, 1); - BOOST_CHECK_CLOSE_VECI(p.pos, e1); - BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angBack, 0)); + const auto position = link.positionAt(0, 1); + BOOST_CHECK_CLOSE_VECI(position.pos, endPos); + BOOST_CHECK_CLOSE_VEC(position.rot, glm::vec3(0, angBack, 0)); } } { // The other way... - const TestLinkCurve l(e1, {}, ctr); - BOOST_CHECK_EQUAL(l.radius, 1.F); + const TestLinkCurve link(endPos, {}, ctr); + BOOST_CHECK_EQUAL(link.radius, 1.F); { - const auto p = l.positionAt(0, 0); - const auto angForReversed = normalize(vector_yaw(difference({}, e1)) * 2 - angFor); - BOOST_CHECK_CLOSE_VECI(p.pos, e1); - BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angForReversed, 0)); + const auto position = link.positionAt(0, 0); + const auto angForReversed = normalize(vector_yaw(difference({}, endPos)) * 2 - angFor); + BOOST_CHECK_CLOSE_VECI(position.pos, endPos); + BOOST_CHECK_CLOSE_VEC(position.rot, glm::vec3(0, angForReversed, 0)); } { - const auto p = l.positionAt(0, 1); - const auto angBackReversed = normalize(vector_yaw(difference(e1, {})) * 2 - angBack); - BOOST_CHECK_CLOSE_VECI(p.pos, GlobalPosition3D {}); - BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angBackReversed, 0)); + const auto position = link.positionAt(0, 1); + const auto angBackReversed = normalize(vector_yaw(difference(endPos, {})) * 2 - angBack); + BOOST_CHECK_CLOSE_VECI(position.pos, GlobalPosition3D {}); + BOOST_CHECK_CLOSE_VEC(position.rot, glm::vec3(0, angBackReversed, 0)); } } } -BOOST_AUTO_TEST_CASE(camera_clicks) +BOOST_AUTO_TEST_CASE(CameraClicks) { Camera camera {{}, ::half_pi, 1.25F, 1000, 10000000}; - constexpr float centre {0.5F}, right {0.9F}, left {0.1F}, top {1.F}, bottom {0.F}; + constexpr float CENTRE {0.5F}, RIGHT {0.9F}, LEFT {0.1F}, TOP {1.F}, BOTTOM {0.F}; camera.setForward(::north); - BOOST_CHECK_EQUAL(camera.unProject({centre, centre}).start, GlobalPosition3D {}); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, ::north); - BOOST_CHECK_CLOSE_VEC(camera.unProject({left, centre}).direction, glm::normalize(::north + ::west)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({right, centre}).direction, glm::normalize(::north + ::east)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, top}).direction, glm::normalize(::north + ::up)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, bottom}).direction, glm::normalize(::north + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({left, top}).direction, glm::normalize(::north + ::west + ::up)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({right, top}).direction, glm::normalize(::north + ::east + ::up)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({left, bottom}).direction, glm::normalize(::north + ::west + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({right, bottom}).direction, glm::normalize(::north + ::east + ::down)); + BOOST_CHECK_EQUAL(camera.unProject({CENTRE, CENTRE}).start, GlobalPosition3D {}); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, CENTRE}).direction, ::north); + BOOST_CHECK_CLOSE_VEC(camera.unProject({LEFT, CENTRE}).direction, glm::normalize(::north + ::west)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({RIGHT, CENTRE}).direction, glm::normalize(::north + ::east)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, TOP}).direction, glm::normalize(::north + ::up)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, BOTTOM}).direction, glm::normalize(::north + ::down)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({LEFT, TOP}).direction, glm::normalize(::north + ::west + ::up)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({RIGHT, TOP}).direction, glm::normalize(::north + ::east + ::up)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({LEFT, BOTTOM}).direction, glm::normalize(::north + ::west + ::down)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({RIGHT, BOTTOM}).direction, glm::normalize(::north + ::east + ::down)); camera.setForward(::east); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, ::east); - BOOST_CHECK_CLOSE_VEC(camera.unProject({left, centre}).direction, glm::normalize(::north + ::east)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({right, centre}).direction, glm::normalize(::south + ::east)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, CENTRE}).direction, ::east); + BOOST_CHECK_CLOSE_VEC(camera.unProject({LEFT, CENTRE}).direction, glm::normalize(::north + ::east)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({RIGHT, CENTRE}).direction, glm::normalize(::south + ::east)); camera.setForward(glm::normalize(::north + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, glm::normalize(::north + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, top}).direction, glm::normalize(::north)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, CENTRE}).direction, glm::normalize(::north + ::down)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, TOP}).direction, glm::normalize(::north)); camera.setForward(glm::normalize(::north + ::west + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, glm::normalize(::north + ::west + ::down)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, top}).direction, glm::normalize(::north + ::west + ::up * 0.2F)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, CENTRE}).direction, glm::normalize(::north + ::west + ::down)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, TOP}).direction, glm::normalize(::north + ::west + ::up * 0.2F)); camera.setForward(glm::normalize(::north + ::west)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, glm::normalize(::north + ::west)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, top}).direction, glm::normalize(::north + ::west + ::up * 1.2F)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({right, centre}).direction, glm::normalize(::north)); - BOOST_CHECK_CLOSE_VEC(camera.unProject({left, centre}).direction, glm::normalize(::west)); -} - -template -auto -n_test_points_between(std::size_t n = 2, T min = -100.F, T max = 100.F) -{ - return boost::unit_test::data::xrange(n) ^ boost::unit_test::data::random(min, max); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, CENTRE}).direction, glm::normalize(::north + ::west)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({CENTRE, TOP}).direction, glm::normalize(::north + ::west + ::up * 1.2F)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({RIGHT, CENTRE}).direction, glm::normalize(::north)); + BOOST_CHECK_CLOSE_VEC(camera.unProject({LEFT, CENTRE}).direction, glm::normalize(::west)); } -BOOST_DATA_TEST_CASE(rayLineDistance, - n_test_points_between() * // n1x - n_test_points_between() * // n1y - n_test_points_between() * // n1z - n_test_points_between() * // n2x - n_test_points_between() * // n2y - n_test_points_between() * // n2z - n_test_points_between() * // cx - n_test_points_between() * // cy - n_test_points_between(), // cz - i1, n1x, i2, n1y, i3, n1z, i4, n2x, i5, n2y, i6, n2z, i7, cx, i8, cy, i9, cz) +BOOST_DATA_TEST_CASE(RayLineDistance, + nTestPointsBetween() * // n1x + nTestPointsBetween() * // n1y + nTestPointsBetween() * // n1z + nTestPointsBetween() * // n2x + nTestPointsBetween() * // n2y + nTestPointsBetween() * // n2z + nTestPointsBetween() * // cx + nTestPointsBetween() * // cy + nTestPointsBetween(), // cz + idx1, n1x, idx2, n1y, idx3, n1z, idx4, n2x, idx5, n2y, idx6, n2z, idx7, originx, idx8, originy, idx9, originz) { - (void)i1; - (void)i2; - (void)i3; - (void)i4; - (void)i5; - (void)i6; - (void)i7; - (void)i8; - (void)i9; - const glm::vec3 n1 {n1x, n1y, n1z}, n2 {n2x, n2y, n2z}, c {cx, cy, cz}; - - const auto nstep = n2 - n1; + (void)idx1; + (void)idx2; + (void)idx3; + (void)idx4; + (void)idx5; + (void)idx6; + (void)idx7; + (void)idx8; + (void)idx9; + const glm::vec3 node1 {n1x, n1y, n1z}, node2 {n2x, n2y, n2z}, origin {originx, originy, originz}; + + const auto nstep = node2 - node1; for (float along = 0.2F; along <= 0.8F; along += 0.1F) { - const auto target = n1 + (along * nstep); - const auto direction = glm::normalize(target - c); - BOOST_CHECK_LE(Ray(c, direction).distanceToLine(n1, n2), 0.01F); + const auto target = node1 + (along * nstep); + const auto direction = glm::normalize(target - origin); + BOOST_CHECK_LE(Ray(origin, direction).distanceToLine(node1, node2), 0.01F); } } @@ -343,44 +347,44 @@ static_assert(linesIntersectAt(GlobalPosition2D {311000100, 491100100}, {3110500 == GlobalPosition2D {311000100, 491100100}); static_assert(!linesIntersectAt(glm::dvec2 {0, 1}, {0, 4}, {1, 8}, {1, 4}).has_value()); -BOOST_AUTO_TEST_CASE(triangle2d_helpers) +BOOST_AUTO_TEST_CASE(Triangle2dHelpers) { - constexpr static Triangle<2, float> t {{0, 0}, {5, 0}, {5, 5}}; + constexpr static Triangle<2, float> TRIANGLE {{0, 0}, {5, 0}, {5, 5}}; - BOOST_CHECK_CLOSE(t.angle(0), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({0, 0}), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angle(1), half_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({5, 0}), half_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angle(2), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({5, 5}), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angle(0), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({0, 0}), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angle(1), half_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({5, 0}), half_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angle(2), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({5, 5}), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({0, 1}), 0.F, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({0, 1}), 0.F, 0.01F); - BOOST_CHECK_CLOSE(t.area(), 12.5F, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.area(), 12.5F, 0.01F); } -BOOST_AUTO_TEST_CASE(triangle3d_helpers) +BOOST_AUTO_TEST_CASE(Triangle3dHelpers) { - constexpr static Triangle<3, float> t {{0, 0, 0}, {5, 0, 0}, {5, 5, 0}}; + constexpr static Triangle<3, float> TRIANGLE {{0, 0, 0}, {5, 0, 0}, {5, 5, 0}}; - BOOST_CHECK_EQUAL(t.nnormal(), up); - BOOST_CHECK_CLOSE(t.angle(0), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({0, 0, 0}), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angle(1), half_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({5, 0, 0}), half_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angle(2), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({5, 5, 0}), quarter_pi, 0.01F); + BOOST_CHECK_EQUAL(TRIANGLE.nnormal(), up); + BOOST_CHECK_CLOSE(TRIANGLE.angle(0), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({0, 0, 0}), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angle(1), half_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({5, 0, 0}), half_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angle(2), quarter_pi, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({5, 5, 0}), quarter_pi, 0.01F); - BOOST_CHECK_CLOSE(t.angleAt({0, 1, 0}), 0.F, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.angleAt({0, 1, 0}), 0.F, 0.01F); - BOOST_CHECK_CLOSE(t.area(), 12.5F, 0.01F); + BOOST_CHECK_CLOSE(TRIANGLE.area(), 12.5F, 0.01F); } using ArcLineIntersectExp = std::pair; using ArcLineIntersectData = std::tuple>; -BOOST_DATA_TEST_CASE(arcline_intersection, +BOOST_DATA_TEST_CASE(ArclineIntersection, boost::unit_test::data::make({ {{0, 0}, {0, 100}, {100, 0}, {200, 0}, {0, 200}, std::nullopt}, {{0, 0}, {0, 100}, {100, 0}, {0, 0}, {10, 10}, std::nullopt}, diff --git a/test/test-network.cpp b/test/test-network.cpp index 19a740e..1c91981 100644 --- a/test/test-network.cpp +++ b/test/test-network.cpp @@ -21,122 +21,126 @@ BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); -struct TestLinkS; - -struct TestLink : public virtual Link { - using StraightLink = TestLinkS; - using CurveLink = TestLinkS; -}; - -struct TestLinkS : public TestLink, public LinkStraight { - TestLinkS(NetworkLinkHolder & network, const Node::Ptr & a, const Node::Ptr & b) : - TestLinkS {network, a, b, (a->pos - b->pos)} - { - } +namespace { + struct TestLinkS; + + struct TestLink : public virtual Link { + using StraightLink = TestLinkS; + using CurveLink = TestLinkS; + }; + + struct TestLinkS : public TestLink, public LinkStraight { + TestLinkS(NetworkLinkHolder & network, const Node::Ptr & nodeA, const Node::Ptr & nodeB) : + TestLinkS {network, nodeA, nodeB, (nodeA->pos - nodeB->pos)} + { + } - TestLinkS(NetworkLinkHolder &, Node::Ptr a, Node::Ptr b, RelativePosition2D l) : - Link {{std::move(a), 0}, {std::move(b), pi}, glm::length(l)} - { - } + TestLinkS(NetworkLinkHolder &, Node::Ptr nodeA, Node::Ptr nodeB, RelativePosition2D difference) : + Link {{.node = std::move(nodeA), .dir = 0}, {.node = std::move(nodeB), .dir = pi}, glm::length(difference)} + { + } - struct Vertex { }; + struct Vertex { }; - TestLinkS(NetworkLinkHolder &, Node::Ptr a, Node::Ptr b, float l) : - Link {{std::move(a), 0}, {std::move(b), pi}, l} - { - } -}; + TestLinkS(NetworkLinkHolder &, Node::Ptr nodeA, Node::Ptr nodeB, float length) : + Link {{.node = std::move(nodeA), .dir = 0}, {.node = std::move(nodeB), .dir = pi}, length} + { + } + }; -constexpr GlobalPosition3D p000 {0, 0, 500}, p100 {10500, 0, 1000}, p200 {20100, 0, 2000}, p300 {30700, 0, 3000}; -constexpr GlobalPosition3D p110 {10300, 10400, 4000}; + constexpr GlobalPosition3D P000 {0, 0, 500}, P100 {10500, 0, 1000}, P200 {20100, 0, 2000}, P300 {30700, 0, 3000}; + constexpr GlobalPosition3D P110 {10300, 10400, 4000}; +} template<> NetworkLinkHolder::NetworkLinkHolder() = default; -struct TestNetwork : public NetworkOf { - TestNetwork() : NetworkOf {RESDIR "rails.jpg"} - { - // 0 1 2 - // p000 <-> p100 <-> p200 <-> p300 - // \ | / - // \ 5 / - // 3 | 4 - // \-> p110 <-/ - addLink(p000, p100, 1.F); - addLink(p100, p200, 1.F); - addLink(p200, p300, 1.F); - addLink(p000, p110, 2.F); - addLink(p200, p110, 2.F); - addLink(p100, p110, 1.F); - } +namespace { + struct TestNetwork : public NetworkOf { + TestNetwork() : NetworkOf {RESDIR "rails.jpg"} + { + // 0 1 2 + // p000 <-> p100 <-> p200 <-> p300 + // \ | / + // \ 5 / + // 3 | 4 + // \-> p110 <-/ + addLink(P000, P100, 1.F); + addLink(P100, P200, 1.F); + addLink(P200, P300, 1.F); + addLink(P000, P110, 2.F); + addLink(P200, P110, 2.F); + addLink(P100, P110, 1.F); + } - void - render(const SceneShader &, const Frustum &) const override - { - } + void + render(const SceneShader &, const Frustum &) const override + { + } - const Surface * - getBaseSurface() const override - { - return nullptr; - } + const Surface * + getBaseSurface() const override + { + return nullptr; + } - RelativeDistance - getBaseWidth() const override - { - return 5'700; - } -}; - -const auto VALID_NODES = boost::unit_test::data::make({ - p000, - p100, - p200, - p300, -}); -const auto INVALID_NODES = boost::unit_test::data::make({ - {1000, 0, 0}, - {0, 1000, 0}, - {0, 0, 1000}, -}); + RelativeDistance + getBaseWidth() const override + { + return 5'700; + } + }; + + constexpr auto VALID_NODES = std::array({ + P000, + P100, + P200, + P300, + }); + constexpr auto INVALID_NODES = std::array({ + {1000, 0, 0}, + {0, 1000, 0}, + {0, 0, 1000}, + }); +} BOOST_FIXTURE_TEST_SUITE(tn, TestNetwork) -BOOST_DATA_TEST_CASE(findNodeAt_valid, VALID_NODES, p) +BOOST_DATA_TEST_CASE(FindNodeAtValid, VALID_NODES, point) { - auto n = findNodeAt(p); - BOOST_REQUIRE(n); - BOOST_CHECK_EQUAL(n->pos, p); + auto node = findNodeAt(point); + BOOST_REQUIRE(node); + BOOST_CHECK_EQUAL(node->pos, point); } -BOOST_DATA_TEST_CASE(findNodeAt_invalid, INVALID_NODES, p) +BOOST_DATA_TEST_CASE(FindNodeAtInvalid, INVALID_NODES, point) { - BOOST_REQUIRE(!findNodeAt(p)); + BOOST_REQUIRE(!findNodeAt(point)); } -BOOST_DATA_TEST_CASE(nodeAt, VALID_NODES + INVALID_NODES, p) +BOOST_DATA_TEST_CASE(NodeAt, VALID_NODES + INVALID_NODES, point) { - auto n = nodeAt(p); - BOOST_REQUIRE(n); - BOOST_CHECK_EQUAL(n->pos, p); + auto node = nodeAt(point); + BOOST_REQUIRE(node); + BOOST_CHECK_EQUAL(node->pos, point); } -BOOST_DATA_TEST_CASE(newNodeAt_existing, VALID_NODES, p) +BOOST_DATA_TEST_CASE(NewNodeAtExisting, VALID_NODES, point) { - auto n = newNodeAt(p); - BOOST_CHECK_EQUAL(n.second, Network::NodeIs::InNetwork); - BOOST_REQUIRE(n.first); - BOOST_CHECK_EQUAL(n.first->pos, p); + auto node = newNodeAt(point); + BOOST_CHECK_EQUAL(node.second, Network::NodeIs::InNetwork); + BOOST_REQUIRE(node.first); + BOOST_CHECK_EQUAL(node.first->pos, point); } -BOOST_DATA_TEST_CASE(newNodeAt_new, INVALID_NODES, p) +BOOST_DATA_TEST_CASE(NewNodeAtNew, INVALID_NODES, point) { - auto n = newNodeAt(p); - BOOST_CHECK_EQUAL(n.second, Network::NodeIs::NotInNetwork); - BOOST_REQUIRE(n.first); - BOOST_CHECK_EQUAL(n.first->pos, p); + auto node = newNodeAt(point); + BOOST_CHECK_EQUAL(node.second, Network::NodeIs::NotInNetwork); + BOOST_REQUIRE(node.first); + BOOST_CHECK_EQUAL(node.first->pos, point); } -BOOST_AUTO_TEST_CASE(network_joins) +BOOST_AUTO_TEST_CASE(NetworkJoins) { // Ends BOOST_CHECK(links[2]->ends[1].nexts.empty()); @@ -160,75 +164,67 @@ BOOST_AUTO_TEST_CASE(network_joins) BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].second, 1); } -BOOST_DATA_TEST_CASE(routeTo_nodeNotInNetwork, INVALID_NODES, dest) +BOOST_DATA_TEST_CASE(RouteToNodeNotInNetwork, INVALID_NODES, dest) { const auto & start = links[0]->ends[1]; BOOST_CHECK_THROW((void)routeFromTo(start, dest), std::out_of_range); } -BOOST_AUTO_TEST_CASE(routeTo_noSteps) +BOOST_AUTO_TEST_CASE(RouteToNoSteps) { const auto & start = links[0]->ends[1]; - auto r = this->routeFromTo(start, p100); - BOOST_CHECK(r.empty()); + auto route = this->routeFromTo(start, P100); + BOOST_CHECK(route.empty()); } -BOOST_AUTO_TEST_CASE(routeTo_upStream_to2) +BOOST_AUTO_TEST_CASE(RouteToUpStreamTo2) { const auto & start = links[0]->ends[1]; - auto r = this->routeFromTo(start, p200); - BOOST_REQUIRE_EQUAL(r.size(), 1); - BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get()); + auto route = this->routeFromTo(start, P200); + BOOST_REQUIRE_EQUAL(route.size(), 1); + BOOST_CHECK_EQUAL(route[0].first.lock().get(), links[1].get()); } -BOOST_AUTO_TEST_CASE(routeTo_upStream_to3) +BOOST_AUTO_TEST_CASE(RouteToUpStreamTo3) { const auto & start = links[0]->ends[1]; - auto r = this->routeFromTo(start, p300); - BOOST_REQUIRE_EQUAL(r.size(), 2); - BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get()); - BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get()); + auto route = this->routeFromTo(start, P300); + BOOST_REQUIRE_EQUAL(route.size(), 2); + BOOST_CHECK_EQUAL(route[0].first.lock().get(), links[1].get()); + BOOST_CHECK_EQUAL(route[1].first.lock().get(), links[2].get()); } -BOOST_AUTO_TEST_CASE(routeTo_downStream_to0) +BOOST_AUTO_TEST_CASE(RouteToDownStreamTo0) { const auto & start = links[2]->ends[0]; - auto r = this->routeFromTo(start, p000); - BOOST_REQUIRE_EQUAL(r.size(), 2); - BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get()); - BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[0].get()); + auto route = this->routeFromTo(start, P000); + BOOST_REQUIRE_EQUAL(route.size(), 2); + BOOST_CHECK_EQUAL(route[0].first.lock().get(), links[1].get()); + BOOST_CHECK_EQUAL(route[1].first.lock().get(), links[0].get()); } -BOOST_AUTO_TEST_CASE(routeTo_upStream_3to300) +BOOST_AUTO_TEST_CASE(RouteToUpStream3to300) { const auto & start = links[3]->ends[1]; - auto r = this->routeFromTo(start, p300); - BOOST_REQUIRE_EQUAL(r.size(), 2); - BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[4].get()); - BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get()); + auto route = this->routeFromTo(start, P300); + BOOST_REQUIRE_EQUAL(route.size(), 2); + BOOST_CHECK_EQUAL(route[0].first.lock().get(), links[4].get()); + BOOST_CHECK_EQUAL(route[1].first.lock().get(), links[2].get()); } -BOOST_AUTO_TEST_CASE(routeTo_downStream_3to300) +BOOST_AUTO_TEST_CASE(RouteToDownStream3to300) { const auto & start = links[3]->ends[0]; - auto r = this->routeFromTo(start, p300); - BOOST_REQUIRE_EQUAL(r.size(), 3); - BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[0].get()); - BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[1].get()); - BOOST_CHECK_EQUAL(r[2].first.lock().get(), links[2].get()); + auto route = this->routeFromTo(start, P300); + BOOST_REQUIRE_EQUAL(route.size(), 3); + BOOST_CHECK_EQUAL(route[0].first.lock().get(), links[0].get()); + BOOST_CHECK_EQUAL(route[1].first.lock().get(), links[1].get()); + BOOST_CHECK_EQUAL(route[2].first.lock().get(), links[2].get()); } BOOST_AUTO_TEST_SUITE_END() -namespace std { - std::ostream & - operator<<(std::ostream & s, const Link::End & e) - { - return s << std::format("End[dir: {}, loc: ({}, {}, {})]", e.dir, e.node->pos.x, e.node->pos.y, e.node->pos.z); - } -} - -BOOST_FIXTURE_TEST_CASE(test_rail_network, RailLinks) +BOOST_FIXTURE_TEST_CASE(TestRailNetwork, RailLinks) { // 0 1 2 // --p000 <-> p100 <-> p200 <-> p300 \ x @@ -239,60 +235,60 @@ BOOST_FIXTURE_TEST_CASE(test_rail_network, RailLinks) // \ | \ / // \ / ------/ // -------- - auto l0 = addLinksBetween(p000, p100); - BOOST_CHECK(dynamic_cast(l0.get())); - BOOST_CHECK_EQUAL(l0->length, ::distance(p000, p100)); - BOOST_CHECK_CLOSE(l0->ends[0].dir, half_pi, 0.1F); - BOOST_CHECK_CLOSE(l0->ends[1].dir, -half_pi, 0.1F); - BOOST_CHECK(l0->ends[0].nexts.empty()); - BOOST_CHECK(l0->ends[1].nexts.empty()); - - auto l1 = addLinksBetween(p200, p100); - BOOST_CHECK(dynamic_cast(l1.get())); - BOOST_CHECK_EQUAL(l1->length, ::distance(p200, p100)); - BOOST_CHECK_CLOSE(l1->ends[0].dir, half_pi, 0.1F); - BOOST_CHECK_CLOSE(l1->ends[1].dir, -half_pi, 0.1F); - BOOST_CHECK(l0->ends[0].nexts.empty()); - BOOST_CHECK_EQUAL(l0->ends[1].nexts.at(0).first.lock(), l1); - BOOST_CHECK_EQUAL(l0->ends[1].nexts.at(0).second, 0); - BOOST_CHECK_EQUAL(l1->ends[0].nexts.at(0).first.lock(), l0); - BOOST_CHECK_EQUAL(l1->ends[0].nexts.at(0).second, 1); - BOOST_CHECK(l1->ends[1].nexts.empty()); - - auto l2 = addLinksBetween(p200, p300); - BOOST_CHECK(dynamic_cast(l2.get())); - BOOST_CHECK_EQUAL(l2->length, ::distance(p200, p300)); - BOOST_CHECK_CLOSE(l2->ends[0].dir, half_pi, 0.1F); - BOOST_CHECK_CLOSE(l2->ends[1].dir, -half_pi, 0.1F); - BOOST_CHECK(l0->ends[0].nexts.empty()); - BOOST_CHECK_EQUAL(l1->ends[1].nexts.at(0).first.lock(), l2); - BOOST_CHECK_EQUAL(l1->ends[1].nexts.at(0).second, 0); - BOOST_CHECK_EQUAL(l2->ends[0].nexts.at(0).first.lock(), l1); - BOOST_CHECK_EQUAL(l2->ends[0].nexts.at(0).second, 1); - BOOST_CHECK(l2->ends[1].nexts.empty()); - - BOOST_CHECK_IF(l3, addLinksBetween(p000, p110)) { - BOOST_CHECK_IF(l3c, dynamic_cast(l3.get())) { - BOOST_CHECK_CLOSE(l3c->radius, 10'300.F, 0.1F); - BOOST_CHECK_CLOSE(l3c->arc.length(), pi + half_pi, 0.5F); - BOOST_CHECK_CLOSE(l3->length, 48'563.F, 0.1F); - BOOST_CHECK_CLOSE(l3->ends[0].dir, -half_pi, 0.5F); - BOOST_CHECK_CLOSE(l3->ends[1].dir, -0.0097F, 0.5F); - BOOST_CHECK_EQUAL(l0->ends[0].nexts.at(0).first.lock(), l3); - BOOST_CHECK_EQUAL(l0->ends[0].nexts.at(0).second, 0); - BOOST_CHECK_EQUAL(l3->ends[0].nexts.at(0).first.lock(), l0); - BOOST_CHECK_EQUAL(l3->ends[0].nexts.at(0).second, 0); - BOOST_CHECK(l3->ends[1].nexts.empty()); + auto link0 = addLinksBetween(P000, P100); + BOOST_CHECK(dynamic_cast(link0.get())); + BOOST_CHECK_EQUAL(link0->length, ::distance(P000, P100)); + BOOST_CHECK_CLOSE(link0->ends[0].dir, half_pi, 0.1F); + BOOST_CHECK_CLOSE(link0->ends[1].dir, -half_pi, 0.1F); + BOOST_CHECK(link0->ends[0].nexts.empty()); + BOOST_CHECK(link0->ends[1].nexts.empty()); + + auto link1 = addLinksBetween(P200, P100); + BOOST_CHECK(dynamic_cast(link1.get())); + BOOST_CHECK_EQUAL(link1->length, ::distance(P200, P100)); + BOOST_CHECK_CLOSE(link1->ends[0].dir, half_pi, 0.1F); + BOOST_CHECK_CLOSE(link1->ends[1].dir, -half_pi, 0.1F); + BOOST_CHECK(link0->ends[0].nexts.empty()); + BOOST_CHECK_EQUAL(link0->ends[1].nexts.at(0).first.lock(), link1); + BOOST_CHECK_EQUAL(link0->ends[1].nexts.at(0).second, 0); + BOOST_CHECK_EQUAL(link1->ends[0].nexts.at(0).first.lock(), link0); + BOOST_CHECK_EQUAL(link1->ends[0].nexts.at(0).second, 1); + BOOST_CHECK(link1->ends[1].nexts.empty()); + + auto link2 = addLinksBetween(P200, P300); + BOOST_CHECK(dynamic_cast(link2.get())); + BOOST_CHECK_EQUAL(link2->length, ::distance(P200, P300)); + BOOST_CHECK_CLOSE(link2->ends[0].dir, half_pi, 0.1F); + BOOST_CHECK_CLOSE(link2->ends[1].dir, -half_pi, 0.1F); + BOOST_CHECK(link0->ends[0].nexts.empty()); + BOOST_CHECK_EQUAL(link1->ends[1].nexts.at(0).first.lock(), link2); + BOOST_CHECK_EQUAL(link1->ends[1].nexts.at(0).second, 0); + BOOST_CHECK_EQUAL(link2->ends[0].nexts.at(0).first.lock(), link1); + BOOST_CHECK_EQUAL(link2->ends[0].nexts.at(0).second, 1); + BOOST_CHECK(link2->ends[1].nexts.empty()); + + BOOST_CHECK_IF(link3, addLinksBetween(P000, P110)) { + BOOST_CHECK_IF(link3c, dynamic_cast(link3.get())) { + BOOST_CHECK_CLOSE(link3c->radius, 10'300.F, 0.1F); + BOOST_CHECK_CLOSE(link3c->arc.length(), pi + half_pi, 0.5F); + BOOST_CHECK_CLOSE(link3->length, 48'563.F, 0.1F); + BOOST_CHECK_CLOSE(link3->ends[0].dir, -half_pi, 0.5F); + BOOST_CHECK_CLOSE(link3->ends[1].dir, -0.0097F, 0.5F); + BOOST_CHECK_EQUAL(link0->ends[0].nexts.at(0).first.lock(), link3); + BOOST_CHECK_EQUAL(link0->ends[0].nexts.at(0).second, 0); + BOOST_CHECK_EQUAL(link3->ends[0].nexts.at(0).first.lock(), link0); + BOOST_CHECK_EQUAL(link3->ends[0].nexts.at(0).second, 0); + BOOST_CHECK(link3->ends[1].nexts.empty()); } } - BOOST_CHECK_IF(l4, addLinksBetween(p110, p300)) { - BOOST_CHECK_IF(l4c, dynamic_cast(l4.get())) { - BOOST_CHECK_CLOSE(l4c->radius, 6950.F, 0.1F); - BOOST_CHECK_CLOSE(l4c->arc.length(), 4.456F, 0.1F); - BOOST_CHECK_CLOSE(l4->length, 30'981.F, 0.1F); - BOOST_CHECK_BETWEEN(l4->ends[0].dir, .25F, .26F); - BOOST_CHECK_CLOSE(l4->ends[1].dir, half_pi, 0.1F); + BOOST_CHECK_IF(link4, addLinksBetween(P110, P300)) { + BOOST_CHECK_IF(link4c, dynamic_cast(link4.get())) { + BOOST_CHECK_CLOSE(link4c->radius, 6950.F, 0.1F); + BOOST_CHECK_CLOSE(link4c->arc.length(), 4.456F, 0.1F); + BOOST_CHECK_CLOSE(link4->length, 30'981.F, 0.1F); + BOOST_CHECK_BETWEEN(link4->ends[0].dir, .25F, .26F); + BOOST_CHECK_CLOSE(link4->ends[1].dir, half_pi, 0.1F); } } } diff --git a/test/test-pack.cpp b/test/test-pack.cpp index 1f9f061..1e5848c 100644 --- a/test/test-pack.cpp +++ b/test/test-pack.cpp @@ -10,7 +10,7 @@ using IntegerVectorPack = pack; BOOST_FIXTURE_TEST_SUITE(pint, IntegerVectorPack) -BOOST_AUTO_TEST_CASE(basics) +BOOST_AUTO_TEST_CASE(Basics) { BOOST_CHECK_EQUAL(size(), 0); BOOST_CHECK_NO_THROW(emplace(1)); 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)); } } diff --git a/test/test-render.cpp b/test/test-render.cpp index a6e28bc..90fa894 100644 --- a/test/test-render.cpp +++ b/test/test-render.cpp @@ -26,119 +26,123 @@ #include #include -class TestScene : public SceneProvider { - RailVehicleClassPtr brush47rvc; - std::shared_ptr train1, train2; - RailLinks rail; - std::shared_ptr env = std::make_shared(); - - std::shared_ptr terrain = std::make_shared(GeoData::createFlat({0, 0}, {1000000, 1000000}, 1)); - Water water {terrain}; - -public: - TestScene() - { - terrain->point(GeoData::VertexHandle {517}).z = 100'000; - terrain->generateMeshes(); - gameState->assets = AssetFactory::loadAll(RESDIR); - brush47rvc = gameState->assets.at("brush-47").dynamicCast(); - std::random_device randomdev {}; - std::uniform_real_distribution rotationDistribution {0, two_pi}; - std::uniform_int_distribution positionOffsetDistribution {-1500, +1500}; - std::uniform_int_distribution treeDistribution {1, 3}; - std::uniform_int_distribution treeVariantDistribution {1, 4}; - train1 = std::make_shared(brush47rvc); - train1->location.setPosition({52000, 50000, 2000}); - train1->bogies.front().setPosition(train1->bogies.front().position() + train1->location.position()); - train1->bogies.back().setPosition(train1->bogies.back().position() + train1->location.position()); - train2 = std::make_shared(brush47rvc); - train2->location.setPosition({52000, 30000, 2000}); - train2->bogies.front().setPosition(train2->bogies.front().position() + train2->location.position()); - train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position()); - for (auto x = 40000; x < 100000; x += 5000) { - for (auto y = 65000; y < 125000; y += 5000) { - gameState->world.create(gameState->assets - .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev), - treeVariantDistribution(randomdev))) - .dynamicCast(), - Location {{x + positionOffsetDistribution(randomdev), y + positionOffsetDistribution(randomdev), - 1}, - {0, rotationDistribution(randomdev), 0}}); +namespace { + class TestScene : public SceneProvider { + RailVehicleClassPtr brush47rvc; + std::shared_ptr train1, train2; + RailLinks rail; + std::shared_ptr env = std::make_shared(); + + std::shared_ptr terrain + = std::make_shared(GeoData::createFlat({0, 0}, {1000000, 1000000}, 1)); + Water water {terrain}; + + public: + TestScene() + { + terrain->point(GeoData::VertexHandle {517}).z = 100'000; + terrain->generateMeshes(); + gameState->assets = AssetFactory::loadAll(RESDIR); + brush47rvc = gameState->assets.at("brush-47").dynamicCast(); + std::random_device randomdev {}; + std::uniform_real_distribution rotationDistribution {0, two_pi}; + std::uniform_int_distribution positionOffsetDistribution {-1500, +1500}; + std::uniform_int_distribution treeDistribution {1, 3}; + std::uniform_int_distribution treeVariantDistribution {1, 4}; + train1 = std::make_shared(brush47rvc); + train1->location.setPosition({52000, 50000, 2000}); + train1->bogies.front().setPosition(train1->bogies.front().position() + train1->location.position()); + train1->bogies.back().setPosition(train1->bogies.back().position() + train1->location.position()); + train2 = std::make_shared(brush47rvc); + train2->location.setPosition({52000, 30000, 2000}); + train2->bogies.front().setPosition(train2->bogies.front().position() + train2->location.position()); + train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position()); + for (auto posX = 40000; posX < 100000; posX += 5000) { + for (auto posY = 65000; posY < 125000; posY += 5000) { + gameState->world.create( + gameState->assets + .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev), + treeVariantDistribution(randomdev))) + .dynamicCast(), + Location {.pos = {posX + positionOffsetDistribution(randomdev), + posY + positionOffsetDistribution(randomdev), 1}, + .rot = {0, rotationDistribution(randomdev), 0}}); + } } + rail.addLinksBetween({42000, 50000, 1000}, {65000, 50000, 1000}); + rail.addLinksBetween({65000, 50000, 1000}, {75000, 45000, 2000}); } - rail.addLinksBetween({42000, 50000, 1000}, {65000, 50000, 1000}); - rail.addLinksBetween({65000, 50000, 1000}, {75000, 45000, 2000}); - } - - void - content(const SceneShader & shader, const Frustum & frustum) const override - { - terrain->render(shader, frustum); - water.render(shader, frustum); - rail.render(shader, frustum); - std::ranges::for_each(gameState->assets, [&shader, &frustum](const auto & asset) { - if (const auto renderable = asset.second.template getAs()) { - renderable->render(shader, frustum); - } - }); - } - - void - lights(const SceneShader &) const override - { - } - - void - environment(const SceneShader &, const SceneRenderer & r) const override - { - env->render(r, *this); - } - - void - shadows(const ShadowMapper & shadowMapper, const Frustum & frustum) const override - { - terrain->shadows(shadowMapper, frustum); - std::ranges::for_each(gameState->assets, [&shadowMapper, &frustum](const auto & asset) { - if (const auto renderable = asset.second.template getAs()) { - renderable->shadows(shadowMapper, frustum); - } - }); - } -}; + + void + content(const SceneShader & shader, const Frustum & frustum) const override + { + terrain->render(shader, frustum); + water.render(shader, frustum); + rail.render(shader, frustum); + std::ranges::for_each(gameState->assets, [&shader, &frustum](const auto & asset) { + if (const auto renderable = asset.second.template getAs()) { + renderable->render(shader, frustum); + } + }); + } + + void + lights(const SceneShader &) const override + { + } + + void + environment(const SceneShader &, const SceneRenderer & renderer) const override + { + env->render(renderer, *this); + } + + void + shadows(const ShadowMapper & shadowMapper, const Frustum & frustum) const override + { + terrain->shadows(shadowMapper, frustum); + std::ranges::for_each(gameState->assets, [&shadowMapper, &frustum](const auto & asset) { + if (const auto renderable = asset.second.template getAs()) { + renderable->shadows(shadowMapper, frustum); + } + }); + } + }; +} BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); -BOOST_DATA_TEST_CASE(cam, +BOOST_DATA_TEST_CASE(Cam, boost::unit_test::data::xrange(500, 30000, 1300) * boost::unit_test::data::xrange(500, 10000, 300) * boost::unit_test::data::xrange(50000, 500000, 70000), dist, near, far) { - static constexpr GlobalPosition4D pos {-10, -10, 60000, 0}; - const Camera cam {pos, half_pi, 1.F, near, far}; + static constexpr GlobalPosition4D POS {-10, -10, 60000, 0}; + const Camera cam {POS, half_pi, 1.F, near, far}; - const auto e = cam.extentsAtDist(dist); + const auto extents = cam.extentsAtDist(dist); - BOOST_CHECK_CLOSE_VECI(e[0], pos + GlobalPosition4D(-dist, dist, -dist, dist)); - BOOST_CHECK_CLOSE_VECI(e[1], pos + GlobalPosition4D(-dist, dist, dist, dist)); - BOOST_CHECK_CLOSE_VECI(e[2], pos + GlobalPosition4D(dist, dist, -dist, dist)); - BOOST_CHECK_CLOSE_VECI(e[3], pos + GlobalPosition4D(dist, dist, dist, dist)); + BOOST_CHECK_CLOSE_VECI(extents[0], POS + GlobalPosition4D(-dist, dist, -dist, dist)); + BOOST_CHECK_CLOSE_VECI(extents[1], POS + GlobalPosition4D(-dist, dist, dist, dist)); + BOOST_CHECK_CLOSE_VECI(extents[2], POS + GlobalPosition4D(dist, dist, -dist, dist)); + BOOST_CHECK_CLOSE_VECI(extents[3], POS + GlobalPosition4D(dist, dist, dist, dist)); } -BOOST_AUTO_TEST_CASE(camSeaFloor) +BOOST_AUTO_TEST_CASE(CamSeaFloor) { const Camera cam {{100, 200, 300}, half_pi, 1.F, 100, 2000}; - const auto e = cam.extentsAtDist(2000); + const auto extents = cam.extentsAtDist(2000); - BOOST_CHECK_CLOSE_VECI(e[0], GlobalPosition4D(-1700, 2000, -1500, 1800)); - BOOST_CHECK_CLOSE_VECI(e[1], GlobalPosition4D(-1900, 2200, 2300, 2000)); - BOOST_CHECK_CLOSE_VECI(e[2], GlobalPosition4D(1900, 2000, -1500, 1800)); - BOOST_CHECK_CLOSE_VECI(e[3], GlobalPosition4D(2100, 2200, 2300, 2000)); + BOOST_CHECK_CLOSE_VECI(extents[0], GlobalPosition4D(-1700, 2000, -1500, 1800)); + BOOST_CHECK_CLOSE_VECI(extents[1], GlobalPosition4D(-1900, 2200, 2300, 2000)); + BOOST_CHECK_CLOSE_VECI(extents[2], GlobalPosition4D(1900, 2000, -1500, 1800)); + BOOST_CHECK_CLOSE_VECI(extents[3], GlobalPosition4D(2100, 2200, 2300, 2000)); } BOOST_FIXTURE_TEST_SUITE(w, TestRenderOutput); -BOOST_AUTO_TEST_CASE(basic) +BOOST_AUTO_TEST_CASE(Basic) { class TestSceneRenderer : public SceneRenderer { using SceneRenderer::SceneRenderer; @@ -155,18 +159,18 @@ BOOST_AUTO_TEST_CASE(basic) } }; - TestSceneRenderer ss {size, output}; - ss.camera.setView({-10000, -10000, 60000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); + TestSceneRenderer renderer {size, output}; + renderer.camera.setView({-10000, -10000, 60000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); const TestScene scene; - ss.render(scene); - ss.saveBuffers("/tmp/basic"); + renderer.render(scene); + renderer.saveBuffers("/tmp/basic"); Texture::save(outImage, "/tmp/basic/final.tga"); } -BOOST_AUTO_TEST_CASE(terrain) +BOOST_AUTO_TEST_CASE(TerrainSD19) { - SceneRenderer ss {size, output}; - ss.camera.setView({310000000, 490000000, 600000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); + SceneRenderer renderer {size, output}; + renderer.camera.setView({310000000, 490000000, 600000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); class TestTerrain : public SceneProvider { std::shared_ptr terrain @@ -181,10 +185,10 @@ BOOST_AUTO_TEST_CASE(terrain) } void - environment(const SceneShader &, const SceneRenderer & sr) const override + environment(const SceneShader &, const SceneRenderer & renderer) const override { - sr.setAmbientLight({0.1, 0.1, 0.1}); - sr.setDirectionalLight({1, 1, 1}, {{0, quarter_pi}}, *this); + renderer.setAmbientLight({0.1, 0.1, 0.1}); + renderer.setDirectionalLight({1, 1, 1}, {{0, quarter_pi}}, *this); } void @@ -199,14 +203,14 @@ BOOST_AUTO_TEST_CASE(terrain) } }; - ss.render(TestTerrain {}); + renderer.render(TestTerrain {}); Texture::save(outImage, "/tmp/terrain.tga"); } -BOOST_AUTO_TEST_CASE(railnet) +BOOST_AUTO_TEST_CASE(RailNetwork) { - SceneRenderer ss {size, output}; - ss.camera.setView({0, 0, 10000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); + SceneRenderer renderer {size, output}; + renderer.camera.setView({0, 0, 10000}, glm::normalize(glm::vec3 {1, 1, -0.5F})); class TestRail : public SceneProvider { RailLinks net; @@ -228,10 +232,10 @@ BOOST_AUTO_TEST_CASE(railnet) } void - environment(const SceneShader &, const SceneRenderer & sr) const override + environment(const SceneShader &, const SceneRenderer & renderer) const override { - sr.setAmbientLight({0.1, 0.1, 0.1}); - sr.setDirectionalLight({1, 1, 1}, {{0, quarter_pi}}, *this); + renderer.setAmbientLight({0.1, 0.1, 0.1}); + renderer.setDirectionalLight({1, 1, 1}, {{0, quarter_pi}}, *this); } void @@ -245,7 +249,7 @@ BOOST_AUTO_TEST_CASE(railnet) } }; - ss.render(TestRail {}); + renderer.render(TestRail {}); Texture::save(outImage, "/tmp/railnet.tga"); } diff --git a/test/test-static-stream_support.cpp b/test/test-static-stream_support.cpp index 6bf9ea4..ec99f52 100644 --- a/test/test-static-stream_support.cpp +++ b/test/test-static-stream_support.cpp @@ -14,7 +14,7 @@ static_assert(NonStringIterableCollection>); static_assert(!NonStringIterableCollection); static_assert(!NonStringIterableCollection); -static_assert(requires(std::vector i, std::ostream & o) { o << i; }); -static_assert(requires(std::array i, std::ostream & o) { o << i; }); -static_assert(requires(std::set i, std::ostream & o) { o << i; }); -static_assert(requires(std::map i, std::ostream & o) { o << i; }); +static_assert(requires(std::vector input, std::ostream & strm) { strm << input; }); +static_assert(requires(std::array input, std::ostream & strm) { strm << input; }); +static_assert(requires(std::set input, std::ostream & strm) { strm << input; }); +static_assert(requires(std::map input, std::ostream & strm) { strm << input; }); diff --git a/test/test-text.cpp b/test/test-text.cpp index 0729ce8..a68718e 100644 --- a/test/test-text.cpp +++ b/test/test-text.cpp @@ -6,7 +6,6 @@ #include #include "testMainWindow.h" -#include "testRenderOutput.h" #include #include #include @@ -16,16 +15,16 @@ BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase); -BOOST_AUTO_TEST_CASE(utf8_string_view_iter) +BOOST_AUTO_TEST_CASE(Utf8StringViewIter) { - static constexpr utf8_string_view text {"Some UTF-8 €£²¹ text."}; - static constexpr std::array codepoints { + static constexpr utf8_string_view TEXT {"Some UTF-8 €£²¹ text."}; + static constexpr std::array CODEPOINTS { 83, 111, 109, 101, 32, 85, 84, 70, 45, 56, 32, 8364, 163, 178, 185, 32, 116, 101, 120, 116, 46}; - BOOST_CHECK_EQUAL(std::count_if(text.begin(), text.end(), isspace), 3); - BOOST_CHECK_EQUAL(text.length(), 21); + BOOST_CHECK_EQUAL(std::count_if(TEXT.begin(), TEXT.end(), isspace), 3); + BOOST_CHECK_EQUAL(TEXT.length(), 21); std::vector codepointsOut; - std::copy(text.begin(), text.end(), std::back_inserter(codepointsOut)); - BOOST_CHECK_EQUAL_COLLECTIONS(codepoints.begin(), codepoints.end(), codepointsOut.begin(), codepointsOut.end()); + std::copy(TEXT.begin(), TEXT.end(), std::back_inserter(codepointsOut)); + BOOST_CHECK_EQUAL_COLLECTIONS(CODEPOINTS.begin(), CODEPOINTS.end(), codepointsOut.begin(), codepointsOut.end()); } struct FontTest : public Font { @@ -36,10 +35,10 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(Font::CharData); using TextureSizeTestData = std::tuple; -BOOST_DATA_TEST_CASE(fontTextureSize, boost::unit_test::data::make({2, 3, 10, 50, 250}), fontHeight) +BOOST_DATA_TEST_CASE(FontTextureSize, boost::unit_test::data::make({2, 3, 10, 50, 250}), fontHeight) { - auto isPowerOfTwo = [](auto x) { - return (x & (x - 1)) == 0; + auto isPowerOfTwo = [](std::integral auto number) { + return (number & (number - 1)) == 0; }; const auto res = Font::getTextureSize(fontHeight); // Power of 2 dimensions... @@ -57,7 +56,7 @@ BOOST_DATA_TEST_CASE(fontTextureSize, boost::unit_test::data::make({2, BOOST_FIXTURE_TEST_SUITE(ft, FontTest); -BOOST_AUTO_TEST_CASE(initialize_chardata) +BOOST_AUTO_TEST_CASE(InitializeCharData) { BOOST_CHECK_GE(charsData.size(), 72); BOOST_CHECK_EQUAL(fontTextures.size(), 2); @@ -65,7 +64,7 @@ BOOST_AUTO_TEST_CASE(initialize_chardata) using CharDataTest = std::tuple; -BOOST_DATA_TEST_CASE(initialize_chardata_A, +BOOST_DATA_TEST_CASE(InitializeCharDataA, boost::unit_test::data::make({ {'A', {0, {34, 35}, {712, 0}, {-1, 35}, 32}}, {'I', {0, {6, 35}, {947, 0}, {4, 35}, 13}}, @@ -74,61 +73,61 @@ BOOST_DATA_TEST_CASE(initialize_chardata_A, }), character, expected) { - const auto & cd = charsData.at(character); - BOOST_CHECK_EQUAL(cd.textureIdx, expected.textureIdx); - BOOST_CHECK_EQUAL(cd.size, expected.size); - BOOST_CHECK_EQUAL(cd.position, expected.position); - BOOST_CHECK_EQUAL(cd.bearing, expected.bearing); - BOOST_CHECK_EQUAL(cd.advance, expected.advance); + const auto & charData = charsData.at(character); + BOOST_CHECK_EQUAL(charData.textureIdx, expected.textureIdx); + BOOST_CHECK_EQUAL(charData.size, expected.size); + BOOST_CHECK_EQUAL(charData.position, expected.position); + BOOST_CHECK_EQUAL(charData.bearing, expected.bearing); + BOOST_CHECK_EQUAL(charData.advance, expected.advance); } static_assert(glm::vec2 {862, 0} / glm::vec2 {2048, 64} == glm::vec2 {0.4208984375, 0}); static_assert(glm::vec2 {866, 35} / glm::vec2 {2048, 64} == glm::vec2 {0.4228515625, 0.546875}); -BOOST_AUTO_TEST_CASE(render_font) +BOOST_AUTO_TEST_CASE(RenderFont) { - constexpr std::string_view text {"I Like Trains"}; - const auto spaces = static_cast(std::count_if(text.begin(), text.end(), isspace)); - const auto tqs = render(text); - BOOST_REQUIRE_EQUAL(tqs.size(), 1); - const auto & t1 = tqs.begin(); - BOOST_CHECK_EQUAL(t1->first, fontTextures.front().texture); - const auto & v = t1->second; - BOOST_CHECK_EQUAL(v.size(), text.size() - spaces); + constexpr std::string_view TEXT {"I Like Trains"}; + const auto spaces = static_cast(std::ranges::count_if(TEXT, isspace)); + const auto textureQuads = render(TEXT); + BOOST_REQUIRE_EQUAL(textureQuads.size(), 1); + const auto & textureQuad = textureQuads.begin(); + BOOST_CHECK_EQUAL(textureQuad->first, fontTextures.front().texture); + const auto & vertices = textureQuad->second; + BOOST_CHECK_EQUAL(vertices.size(), TEXT.size() - spaces); BOOST_TEST_CONTEXT(size) { // I - BOOST_CHECK_CLOSE_VEC(v[0][0], glm::vec4(4, 0, 0.42, 0.54)); - BOOST_CHECK_CLOSE_VEC(v[0][1], glm::vec4(10, 0, 0.42, 0.54)); - BOOST_CHECK_CLOSE_VEC(v[0][2], glm::vec4(10, 35, 0.42, 0)); - BOOST_CHECK_CLOSE_VEC(v[0][3], glm::vec4(4, 35, 0.42, 0)); + BOOST_CHECK_CLOSE_VEC(vertices[0][0], glm::vec4(4, 0, 0.42, 0.54)); + BOOST_CHECK_CLOSE_VEC(vertices[0][1], glm::vec4(10, 0, 0.42, 0.54)); + BOOST_CHECK_CLOSE_VEC(vertices[0][2], glm::vec4(10, 35, 0.42, 0)); + BOOST_CHECK_CLOSE_VEC(vertices[0][3], glm::vec4(4, 35, 0.42, 0)); // (space, no glyph) // L - BOOST_CHECK_CLOSE_VEC(v[1][0], glm::vec4(32, 0, 0.42, 0.54)); - BOOST_CHECK_CLOSE_VEC(v[1][1], glm::vec4(54, 0, 0.42, 0.54)); - BOOST_CHECK_CLOSE_VEC(v[1][2], glm::vec4(54, 35, 0.42, 0)); - BOOST_CHECK_CLOSE_VEC(v[1][3], glm::vec4(32, 35, 0.42, 0)); + BOOST_CHECK_CLOSE_VEC(vertices[1][0], glm::vec4(32, 0, 0.42, 0.54)); + BOOST_CHECK_CLOSE_VEC(vertices[1][1], glm::vec4(54, 0, 0.42, 0.54)); + BOOST_CHECK_CLOSE_VEC(vertices[1][2], glm::vec4(54, 35, 0.42, 0)); + BOOST_CHECK_CLOSE_VEC(vertices[1][3], glm::vec4(32, 35, 0.42, 0)); } } BOOST_AUTO_TEST_SUITE_END() -BOOST_AUTO_TEST_CASE(stream_vec) +BOOST_AUTO_TEST_CASE(StreamVec) { BOOST_CHECK_EQUAL(streamed_string(glm::vec3 {1.2, 2.3, 3.4}), "(1.2, 2.3, 3.4)"); } -BOOST_AUTO_TEST_CASE(stream_array) +BOOST_AUTO_TEST_CASE(StreamArray) { BOOST_CHECK_EQUAL(streamed_string(std::array {1.2, 2.3, 3.4}), "(1.2, 2.3, 3.4)"); } -BOOST_AUTO_TEST_CASE(stream_vector) +BOOST_AUTO_TEST_CASE(StreamVector) { BOOST_CHECK_EQUAL(streamed_string(std::vector {1.2, 2.3, 3.4}), "(1.2, 2.3, 3.4)"); } -BOOST_AUTO_TEST_CASE(stream_mat) +BOOST_AUTO_TEST_CASE(StreamMat) { BOOST_CHECK_EQUAL(streamed_string(glm::mat2 {1.2, 2.3, 3.4, 4.5}), "((1.2, 2.3), (3.4, 4.5))"); } diff --git a/test/test-worker.cpp b/test/test-worker.cpp index cadc366..c259079 100644 --- a/test/test-worker.cpp +++ b/test/test-worker.cpp @@ -1,104 +1,101 @@ #define BOOST_TEST_MODULE test_worker -#include "testHelpers.h" #include #include #include #include -uint32_t -workCounter() -{ - static std::atomic_uint32_t n; - usleep(1000); - return n++; -} +namespace { + uint32_t + workCounter() + { + static std::atomic_uint32_t counter; + usleep(1000); + return counter++; + } -void -workVoid() -{ - usleep(1000); -} + void + workVoid() + { + usleep(1000); + } -void -workFail() -{ - usleep(1000); - throw std::runtime_error {"test"}; + void + workFail() + { + usleep(1000); + throw std::runtime_error {"test"}; + } } -BOOST_AUTO_TEST_CASE(basic_slow_counter) +BOOST_AUTO_TEST_CASE(BasicSlowCounter) { - std::vector> ps; + std::vector> jobs; for (int i {}; i < 30; ++i) { - ps.push_back(Worker::addWork(workCounter)); + jobs.emplace_back(Worker::addWork(workCounter)); } std::set out; - std::transform(ps.begin(), ps.end(), std::inserter(out, out.end()), [](auto && p) { - return p->get(); - }); - BOOST_REQUIRE_EQUAL(out.size(), ps.size()); + std::ranges::transform(jobs, std::inserter(out, out.end()), &Worker::WorkItemT::get); + BOOST_REQUIRE_EQUAL(out.size(), jobs.size()); BOOST_CHECK_EQUAL(*out.begin(), 0); - BOOST_CHECK_EQUAL(*out.rbegin(), ps.size() - 1); + BOOST_CHECK_EQUAL(*out.rbegin(), jobs.size() - 1); } -BOOST_AUTO_TEST_CASE(basic_error_handler) +BOOST_AUTO_TEST_CASE(BasicErrorHandler) { auto workitem = Worker::addWork(workFail); BOOST_CHECK_THROW(workitem->get(), std::runtime_error); } -BOOST_AUTO_TEST_CASE(basic_void_work) +BOOST_AUTO_TEST_CASE(BasicVoidWork) { auto workitem = Worker::addWork(workVoid); BOOST_CHECK_NO_THROW(workitem->get()); } -BOOST_AUTO_TEST_CASE(lambda_void) +BOOST_AUTO_TEST_CASE(LambdaVoid) { - BOOST_CHECK_NO_THROW(Worker::addWork([]() {})->get()); - BOOST_CHECK_NO_THROW(Worker::addWork([](int) {}, 0)->get()); - BOOST_CHECK_NO_THROW(Worker::addWork([](int, int) {}, 0, 0)->get()); + BOOST_CHECK_NO_THROW(Worker::addWork([]() { })->get()); + BOOST_CHECK_NO_THROW(Worker::addWork([](int) { }, 0)->get()); + BOOST_CHECK_NO_THROW(Worker::addWork([](int, int) { }, 0, 0)->get()); } -BOOST_AUTO_TEST_CASE(lambda_value) +BOOST_AUTO_TEST_CASE(LambdaValue) { BOOST_CHECK_EQUAL(1, Worker::addWork([]() { return 1; })->get()); BOOST_CHECK_EQUAL(2, Worker::addWork( - [](int i) { - return i; + [](int value) { + return value; }, 2) ->get()); BOOST_CHECK_EQUAL(3, Worker::addWork( - [](int i, int j) { - return i + j; + [](int valueA, int valueB) { + return valueA + valueB; }, 1, 2) ->get()); } -BOOST_AUTO_TEST_CASE(recursive, *boost::unit_test::timeout(5)) +BOOST_AUTO_TEST_CASE(Recursive, *boost::unit_test::timeout(5)) { auto recurse = []() { - std::vector> ps; + std::vector> jobs; for (int i {}; i < 30; ++i) { - ps.push_back(Worker::addWork(workCounter)); + jobs.emplace_back(Worker::addWork(workCounter)); } - return std::accumulate(ps.begin(), ps.end(), 0U, [](auto && out, auto && p) { - return out += p->get(); + return std::ranges::fold_left(jobs, 0U, [](auto && out, auto && job) { + return out += job->get(); }); }; - std::vector> ps; + std::vector> jobs; for (int i {}; i < 30; ++i) { - ps.push_back(Worker::addWork(recurse)); + jobs.emplace_back(Worker::addWork(recurse)); } std::set out; - std::transform(ps.begin(), ps.end(), std::inserter(out, out.end()), [](auto && p) { - return p->get(); - }); + std::ranges::transform(jobs, std::inserter(out, out.end()), &Worker::WorkItemT::get); } diff --git a/test/testHelpers.cpp b/test/testHelpers.cpp new file mode 100644 index 0000000..7d78cd2 --- /dev/null +++ b/test/testHelpers.cpp @@ -0,0 +1,6 @@ +#include "testHelpers.h" + +const std::filesystem::path ANALYSIS_DIRECTORY = []() { + auto xdgRuntimeDir = getenv("XDG_RUNTIME_DIR"); + return std::filesystem::path {xdgRuntimeDir ? xdgRuntimeDir : "/tmp"} / "ilt-output"; +}(); diff --git a/test/testHelpers.h b/test/testHelpers.h index a261b3d..e1fed97 100644 --- a/test/testHelpers.h +++ b/test/testHelpers.h @@ -11,34 +11,36 @@ template decltype(auto) loadFixtureJson(const std::filesystem::path & path) { - std::ifstream in {FIXTURESDIR / path}; - return Persistence::JsonParsePersistence {}.loadState>(in); + std::ifstream inputStream {FIXTURESDIR / path}; + return Persistence::JsonParsePersistence {}.loadState>(inputStream); } +extern const std::filesystem::path ANALYSIS_DIRECTORY; + #define BOOST_CHECK_CLOSE_VEC(a_, b_) \ { \ - const auto a {a_}, b {b_}; \ - BOOST_TEST_CONTEXT("BOOST_CHECK_CLOSE_VEC(" << std::setprecision(8) << a << ", " << b << ")") { \ - BOOST_CHECK_LT(glm::length(a - b), 0.1F); \ + const auto left_ {a_}, right_ {b_}; \ + BOOST_TEST_CONTEXT("BOOST_CHECK_CLOSE_VEC(" << std::setprecision(8) << left_ << ", " << right_ << ")") { \ + BOOST_CHECK_LT(glm::length(left_ - right_), 0.1F); \ } \ } #define BOOST_CHECK_CLOSE_VECI(a_, b_) \ { \ - const auto a {a_}, b {b_}; \ - BOOST_TEST_CONTEXT("BOOST_CHECK_CLOSE_VEC(" << std::setprecision(8) << a << ", " << b << ")") { \ - BOOST_CHECK_LE(std::abs(a.x - b.x), 1); \ - BOOST_CHECK_LE(std::abs(a.y - b.y), 1); \ - BOOST_CHECK_LE(std::abs(a.z - b.z), 1); \ + const auto left_ {a_}, right_ {b_}; \ + BOOST_TEST_CONTEXT("BOOST_CHECK_CLOSE_VEC(" << std::setprecision(8) << left_ << ", " << right_ << ")") { \ + BOOST_CHECK_LE(std::abs(left_.x - right_.x), 1); \ + BOOST_CHECK_LE(std::abs(left_.y - right_.y), 1); \ + BOOST_CHECK_LE(std::abs(left_.z - right_.z), 1); \ } \ } #define BOOST_CHECK_BETWEEN(a_, b_, c_) \ { \ - const auto a {a_}, b {b_}, c {c_}; \ - BOOST_TEST_CONTEXT("BOOST_CHECK_BETWEEN(" << a << ", " << b << ", " << c << ")") { \ - BOOST_CHECK_LE(b, a); \ - BOOST_CHECK_GE(c, a); \ + const auto value_ {a_}, min_ {b_}, max_ {c_}; \ + BOOST_TEST_CONTEXT("BOOST_CHECK_BETWEEN(" << min_ << " <= " << value_ << " <= " << max_ << ")") { \ + BOOST_CHECK_LE(min_, value_); \ + BOOST_CHECK_GE(max_, value_); \ } \ } #define BOOST_REQUIRE_THEN(VAR, EXPR) \ diff --git a/test/testRenderOutput.cpp b/test/testRenderOutput.cpp index 68b46f6..2c74ceb 100644 --- a/test/testRenderOutput.cpp +++ b/test/testRenderOutput.cpp @@ -2,7 +2,7 @@ #include #include -TestRenderOutput::TestRenderOutput(TextureAbsCoord s) : size {s} +TestRenderOutput::TestRenderOutput(TextureAbsCoord outputSize) : size {outputSize} { glBindFramebuffer(GL_FRAMEBUFFER, output); const auto configuregdata diff --git a/test/testStructures.h b/test/testStructures.h index 4eb4764..61bef68 100644 --- a/test/testStructures.h +++ b/test/testStructures.h @@ -30,7 +30,7 @@ struct TestObject : public Persistence::Persistable { TestObject() = default; float flt {}; - std::string str {}; + std::string str; bool bl {}; RelativePosition3D pos {}; GlobalPosition3D gpos {}; -- cgit v1.2.3