summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--test/.clang-tidy3
-rw-r--r--test/perf-geoData.cpp12
-rw-r--r--test/perf-terrain.cpp2
-rw-r--r--test/test-assetFactory.cpp253
-rw-r--r--test/test-collection.cpp228
-rw-r--r--test/test-enumDetails.cpp12
-rw-r--r--test/test-environment.cpp53
-rw-r--r--test/test-geoData-counts.cpp2
-rw-r--r--test/test-geoData.cpp151
-rw-r--r--test/test-glContainer.cpp109
-rw-r--r--test/test-glContextBhvr.cpp38
-rw-r--r--test/test-instancing.cpp93
-rw-r--r--test/test-lib.cpp64
-rw-r--r--test/test-maths.cpp338
-rw-r--r--test/test-network.cpp350
-rw-r--r--test/test-pack.cpp2
-rw-r--r--test/test-persistence.cpp369
-rw-r--r--test/test-render.cpp224
-rw-r--r--test/test-static-stream_support.cpp8
-rw-r--r--test/test-text.cpp79
-rw-r--r--test/test-worker.cpp91
-rw-r--r--test/testHelpers.cpp6
-rw-r--r--test/testHelpers.h30
-rw-r--r--test/testRenderOutput.cpp2
-rw-r--r--test/testStructures.h2
25 files changed, 1280 insertions, 1241 deletions
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 <game/geoData.h>
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 <benchmark/benchmark.h>
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 <special_members.h>
BOOST_GLOBAL_FIXTURE(TestMainWindowAppBase);
-const std::filesystem::path TMP {"/tmp"};
-
-class FactoryFixture : public TestRenderOutputSize<TextureAbsCoord {2048, 1024}>, 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<const Renderable> objects;
-
-private:
- SceneRenderer sceneRenderer;
-};
-
-BOOST_AUTO_TEST_CASE(surfaces, *boost::unit_test::timeout(5))
+namespace {
+ class FactoryFixture : public TestRenderOutputSize<TextureAbsCoord {2048, 1024}>, 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<const Renderable> 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<Surface>();
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<const Object>(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<RailVehicleClass>();
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<Foliage>();
- BOOST_REQUIRE(tree_01_1_f);
-
- auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}});
- auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}});
- auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}});
- auto plant4 = std::make_shared<Plant>(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<Foliage>();
+ BOOST_REQUIRE(tree011);
+
+ auto plant1 = std::make_shared<Plant>(tree011, Location {.pos = {-2000, 2000, 0}, .rot = {0, 0, 0}});
+ auto plant2 = std::make_shared<Plant>(tree011, Location {.pos = {3000, -4000, 0}, .rot = {0, 1, 0}});
+ auto plant3 = std::make_shared<Plant>(tree011, Location {.pos = {-2000, -4000, 0}, .rot = {0, 2, 0}});
+ auto plant4 = std::make_shared<Plant>(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<Illuminator>();
BOOST_REQUIRE(rlight);
- auto oldlamp = mf->assets.at("old-lamp");
+ auto oldlamp = oldlampAsset.dynamicCast<Illuminator>();
BOOST_REQUIRE(oldlamp);
- auto rlight_f = rlight.dynamicCast<Illuminator>();
- BOOST_REQUIRE(rlight_f);
- auto oldlamp_f = oldlamp.dynamicCast<Illuminator>();
- BOOST_REQUIRE(oldlamp_f);
-
- auto light1 = std::make_shared<Light>(oldlamp_f, Location {{0, 0, 0}, {0, 0, 0}});
- auto light2 = std::make_shared<Light>(rlight_f, Location {{-4000, 0, 0}, {0, 2, 0}});
- auto light3 = std::make_shared<Light>(rlight_f, Location {{-4000, -4000, 0}, {0, 1, 0}});
- auto light4 = std::make_shared<Light>(oldlamp_f, Location {{3000, 4600, 0}, {0, 2, 0}});
- objects.emplace(rlight_f);
- objects.emplace(oldlamp_f);
+
+ auto light1 = std::make_shared<Light>(oldlamp, Location {.pos = {0, 0, 0}, .rot = {0, 0, 0}});
+ auto light2 = std::make_shared<Light>(rlight, Location {.pos = {-4000, 0, 0}, .rot = {0, 2, 0}});
+ auto light3 = std::make_shared<Light>(rlight, Location {.pos = {-4000, -4000, 0}, .rot = {0, 1, 0}});
+ auto light4 = std::make_shared<Light>(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<Foliage>();
+ auto floorf = factory->assets.at("floor").dynamicCast<Foliage>();
auto floor = std::make_shared<Plant>(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<typename T> using InOut = std::tuple<T, T>;
-BOOST_DATA_TEST_CASE(normalizeColourName,
+BOOST_DATA_TEST_CASE(NormalizeColourName,
boost::unit_test::data::make<InOut<std::string>>({
{"", ""},
{"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<TexturePacker::Image> 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<TexturePacker::Image> 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<GLsizei>(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<TexturePacker::Image> 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 <special_members.h>
#include <vector>
-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<Base, Sub>;
+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<Base, Sub>;
+}
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<Sub>::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<Base>());
BOOST_CHECK(!find<Sub>());
BOOST_CHECK(!find<Sub1>());
}
-BOOST_AUTO_TEST_CASE(a_base)
+BOOST_AUTO_TEST_CASE(ABaseApply)
{
- auto b = create<Base>();
+ auto base = create<Base>();
BOOST_CHECK_EQUAL(objects.size(), 1);
BOOST_CHECK(std::get<OtherObjects<Sub>>(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<Base>());
+ BOOST_CHECK_EQUAL(base->total, 1);
+ const auto appliedTo = applyOne(&Base::add);
+ BOOST_CHECK_EQUAL(appliedTo, end());
+ BOOST_CHECK_EQUAL(base.get(), find<Base>());
BOOST_CHECK(!find<Sub>());
BOOST_CHECK(!find<Sub1>());
}
-BOOST_AUTO_TEST_CASE(emplace_others)
+BOOST_AUTO_TEST_CASE(EmplaceOthers)
{
- auto b = emplace(std::make_shared<Base>());
+ auto base = emplace(std::make_shared<Base>());
BOOST_CHECK_EQUAL(objects.size(), 1);
BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
- auto s = emplace(std::make_shared<Sub>());
+ auto sub = emplace(std::make_shared<Sub>());
BOOST_CHECK_EQUAL(objects.size(), 2);
BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
- BOOST_CHECK_EQUAL(b.get(), find<Base>());
- BOOST_CHECK_EQUAL(s.get(), find<Sub>());
+ BOOST_CHECK_EQUAL(base.get(), find<Base>());
+ BOOST_CHECK_EQUAL(sub.get(), find<Sub>());
BOOST_CHECK(!find<Sub1>());
}
-BOOST_AUTO_TEST_CASE(a_rbase)
+BOOST_AUTO_TEST_CASE(ABaseRApply)
{
- auto b = create<Base>();
+ auto base = create<Base>();
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<Sub>();
+ auto sub = create<Sub>();
BOOST_CHECK_EQUAL(objects.size(), 1);
BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(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<Sub>() == 0);
static_assert(TestCollection::idx<const Sub>() == 0);
@@ -156,7 +160,7 @@ BOOST_AUTO_TEST_CASE(filter)
BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor<Sub1>());
}
-BOOST_AUTO_TEST_CASE(begin_end)
+BOOST_AUTO_TEST_CASE(BeginEnd)
{
BOOST_CHECK_EQUAL(0, std::distance(begin(), end()));
create<Sub>();
@@ -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<Sub>();
@@ -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<Base>();
- BOOST_CHECK(b);
- auto b2 = findOrCreate<Base>();
- BOOST_CHECK_EQUAL(b, b2);
- auto s = findOrCreate<Sub>();
- BOOST_CHECK_NE(s, b);
- auto s2 = findOrCreate<Sub>();
- BOOST_CHECK_EQUAL(s, s2);
+ auto base1 = findOrCreate<Base>();
+ BOOST_CHECK(base1);
+ auto base2 = findOrCreate<Base>();
+ BOOST_CHECK_EQUAL(base1, base2);
+ auto sub1 = findOrCreate<Sub>();
+ BOOST_CHECK_NE(sub1, base1);
+ auto sub2 = findOrCreate<Sub>();
+ BOOST_CHECK_EQUAL(sub1, sub2);
}
-BOOST_AUTO_TEST_CASE(createCreateSub)
+BOOST_AUTO_TEST_CASE(CreateCreateSub)
{
- auto s = findOrCreate<Sub>();
- auto b = findOrCreate<Base>();
- BOOST_CHECK_EQUAL(s, b);
+ auto sub = findOrCreate<Sub>();
+ auto base = findOrCreate<Base>();
+ 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<Base>();
BOOST_CHECK_EQUAL(objects.size(), 1);
@@ -211,7 +215,7 @@ BOOST_AUTO_TEST_CASE(unique_create)
BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
}
-BOOST_AUTO_TEST_CASE(move_assign)
+BOOST_AUTO_TEST_CASE(MoveAssign)
{
create<Base>();
create<Sub>();
@@ -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<Base>();
create<Sub>();
@@ -241,7 +245,7 @@ BOOST_AUTO_TEST_CASE(clearAll)
BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
}
-BOOST_AUTO_TEST_CASE(removeAllOfSub)
+BOOST_AUTO_TEST_CASE(RemoveAllOfSub)
{
create<Base>();
create<Sub>();
@@ -258,7 +262,7 @@ BOOST_AUTO_TEST_SUITE_END()
BOOST_FIXTURE_TEST_SUITE(btc, UniqueCollection<Base>)
-BOOST_AUTO_TEST_CASE(no_others)
+BOOST_AUTO_TEST_CASE(NoOthers)
{
create<Base>();
create<Sub>();
@@ -266,7 +270,7 @@ BOOST_AUTO_TEST_CASE(no_others)
emplace(std::make_unique<Sub>());
}
-BOOST_AUTO_TEST_CASE(applyAll)
+BOOST_AUTO_TEST_CASE(ApplyAll)
{
create<Base>();
BOOST_CHECK_EQUAL(0, apply<Sub>(&Base::add));
@@ -276,7 +280,7 @@ BOOST_AUTO_TEST_CASE(applyAll)
BOOST_CHECK_EQUAL(2, apply<Base>(&Base::add));
}
-BOOST_AUTO_TEST_CASE(applyOneType)
+BOOST_AUTO_TEST_CASE(ApplyOneType)
{
create<Base>();
BOOST_CHECK_EQUAL(objects.end(), applyOne<Sub>(&Base::yes));
@@ -294,7 +298,7 @@ using MultiCollection = Collection<std::unique_ptr<Base>, Multi, Sub, Base2>;
BOOST_FIXTURE_TEST_SUITE(multi, MultiCollection)
-BOOST_AUTO_TEST_CASE(addMulti)
+BOOST_AUTO_TEST_CASE(AddMulti)
{
static_assert(MultiCollection::idx<Multi>() == 0);
static_assert(MultiCollection::idx<Sub>() == 1);
@@ -326,7 +330,7 @@ BOOST_AUTO_TEST_CASE(addMulti)
BOOST_CHECK_EQUAL(size<Base2>(), 1);
}
-BOOST_AUTO_TEST_CASE(removeMulti)
+BOOST_AUTO_TEST_CASE(RemoveMulti)
{
create<Base>();
create<Sub>();
@@ -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<FILE, &fclose>;
- 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<FILE, &fclose>;
- 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<FILE, &fopen, &fclose>;
- 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<typename E> 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<TYPE>::isValid(static_cast<TYPE>(input))); \
} \
- BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, input) \
+ BOOST_DATA_TEST_CASE(InvalidParse##TYPE, INVALID_NAMES, input) \
{ \
BOOST_CHECK(!EnumDetails<TYPE>::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<TYPE>::toString(static_cast<TYPE>(input)).has_value()); \
} \
- BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES<TYPE>, input) \
+ BOOST_DATA_TEST_CASE(ValidCheck##TYPE, VALID_VALUES<TYPE>, input) \
{ \
BOOST_CHECK(EnumDetails<TYPE>::isValid(input)); \
} \
- BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, input, output) \
+ BOOST_DATA_TEST_CASE(ValidParse##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, input, output) \
{ \
const auto parsed = EnumDetails<TYPE>::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<TYPE> ^ VALID_NAMES, input, output) \
+ BOOST_DATA_TEST_CASE(ValidToString##TYPE, VALID_VALUES<TYPE> ^ VALID_NAMES, input, output) \
{ \
const auto parsed = EnumDetails<TYPE>::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 <boost/test/data/test_case.hpp>
#include <boost/test/unit_test.hpp>
-#include <cmath>
#include <stream_support.h>
#include <chronology.h>
@@ -11,25 +10,27 @@
#include <gfx/lightDirection.h>
#include <maths.h>
-using sunPosTestData = std::tuple<Direction2D, time_t, Direction2D>;
-using sunDirTestData = std::tuple<Direction2D, Direction3D, float, float>;
-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<Direction2D, time_t, Direction2D>;
+ using SunDirTestData = std::tuple<Direction2D, Direction3D, float, float>;
+ 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<sunPosTestData>({
- {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<SunPosTestData>({
+ {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<sunDirTestData>({
+BOOST_DATA_TEST_CASE(SunDirection,
+ boost::unit_test::data::make<SunDirTestData>({
{{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<Something>({
{"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 <boost/test/data/test_case.hpp>
#include <boost/test/unit_test.hpp>
-#include <gfx/gl/sceneRenderer.h>
#include <stream_support.h>
+#include <game/terrain.h>
+#include <gfx/gl/sceneRenderer.h>
+
#include <game/geoData.h>
-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<GlobalPosition2D, int>;
// 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<FindPointData>({
- {{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<int>(
{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<GlobalPosition2D, GlobalDistance>;
-BOOST_DATA_TEST_CASE(findPositionAt,
+BOOST_DATA_TEST_CASE(FindPositionAt,
boost::unit_test::data::make<FindPositionData>({
// 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<GlobalPosition3D, Direction3D, GlobalPosition3D>;
-BOOST_DATA_TEST_CASE(findRayIntersect,
+BOOST_DATA_TEST_CASE(FindRayIntersect,
boost::unit_test::data::make<FindRayIntersectData>({
{{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<GlobalPosition2D, GlobalPosition2D, std::vector<int>>;
-BOOST_DATA_TEST_CASE(walkTerrain,
+BOOST_DATA_TEST_CASE(WalkTerrain,
boost::unit_test::data::make<WalkTerrainData>({
{{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<int> 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<WalkTerrainData>({
{{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<WalkTerrainData>({
{{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<int> 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<GlobalPosition2D, GlobalPosition2D, Glob
BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
-BOOST_DATA_TEST_CASE(walkTerrainCurveSetsFromFace,
+BOOST_DATA_TEST_CASE(WalkTerrainCurveSetsFromFace,
boost::unit_test::data::make<WalkTerrainCurveData>({
{{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<int> visited;
std::vector<GlobalPosition2D> 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<GlobalPosition2D, GlobalPosition2D, int>;
-BOOST_DATA_TEST_CASE(findEntries,
+BOOST_DATA_TEST_CASE(FindEntryHalfEdge,
boost::unit_test::data::make<FindEntiesData>({
{{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<std::vector<GlobalPosition3D>,
@@ -240,17 +245,15 @@ using DeformTerrainData = std::tuple<std::vector<GlobalPosition3D>,
BOOST_TEST_DECORATOR(*boost::unit_test::timeout(2));
-BOOST_DATA_TEST_CASE(deform, loadFixtureJson<DeformTerrainData>("geoData/deform/1.json"), points, cams)
+BOOST_DATA_TEST_CASE(Deform, loadFixtureJson<DeformTerrainData>("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<DeformTerrainData>("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<DeformTerrainData>("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>(GeoData::createFlat({0, 0}, {1000000, 1000000}, 100));
+ auto geoData = std::make_shared<GeoData>(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<int>)
-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<C>);
+ static_assert(std::is_trivially_destructible_v<C>);
+
+ 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<CC>);
+}
BOOST_FIXTURE_TEST_SUITE(c, glContainer<C>)
-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<CC>);
-
BOOST_FIXTURE_TEST_SUITE(cc, glContainer<CC>)
-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<Uint32>(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<GLADloadfunc>(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<GLADloadfunc>(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<SDL_WindowPtr> window1 {std::in_place, TEST_WINDOW_PARAMS};
const std::optional<SDL_WindowPtr> 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<int> {
- void
- checkReverseIndex(std::source_location ctx = std::source_location::current())
- {
- BOOST_TEST_CONTEXT(ctx.function_name() << ":" << ctx.line()) {
- std::vector<size_t> 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<int> {
+ void
+ checkReverseIndex(std::source_location ctx = std::source_location::current())
+ {
+ BOOST_TEST_CONTEXT(ctx.function_name() << ":" << ctx.line()) {
+ std::vector<size_t> 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<decltype(acquire())> proxies;
std::vector<int> 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<decltype(acquire())> 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<int, InstanceVertices<int>::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<int>(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<size_t> 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<int> dist(0, 100000);
- static constexpr auto N = 1000;
- reserve(N);
+ static constexpr auto COUNT = 1000;
+ reserve(COUNT);
std::vector<decltype(acquire(0))> 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<int> 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 <glad/gl.h>
#include <set>
-std::set<GLuint> active;
+namespace {
+ // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - tracker
+ std::set<GLuint> 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<size_t>(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<int> 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<int, int, int>;
std::vector<TriTuple> outRange;
@@ -82,7 +84,7 @@ BOOST_AUTO_TEST_CASE(triangle_strip_range_adapter)
using MergeCloseData = std::tuple<std::vector<int>, int, std::vector<int>>;
-BOOST_DATA_TEST_CASE(mergeCloseInts,
+BOOST_DATA_TEST_CASE(MergeCloseInts,
boost::unit_test::data::make<MergeCloseData>({
{{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<GlobalDistance>::fromPoints(std::vector<GlobalPosition3D> {
{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 <glm/gtx/transform.hpp>
#include <stream_support.h>
#include <string_view>
-#include <type_traits>
#include <game/network/link.h>
#include <gfx/camera.h>
@@ -15,8 +14,8 @@
#include <triangle.h>
#include <tuple>
-using vecter_and_angle = std::tuple<glm::vec3, float>;
-using angle_pair = std::tuple<float, float>;
+using VecterAndAngle = std::tuple<glm::vec3, Angle>;
+using AnglePair = std::tuple<Angle, Angle>;
//
// 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<vecter_and_angle>(
+BOOST_DATA_TEST_CASE(TestVectorYaw,
+ boost::unit_test::data::make<VecterAndAngle>(
{{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<angle_pair>({
+BOOST_DATA_TEST_CASE(TestAngleNormalize,
+ boost::unit_test::data::make<AnglePair>({
{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<vecter_and_angle>({
+BOOST_DATA_TEST_CASE(TestVectorPitch,
+ boost::unit_test::data::make<VecterAndAngle>({
{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<std::tuple<glm::vec3, glm::mat4 (*)(float), std::string_view>>({
+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<std::tuple<glm::vec3, glm::mat4 (*)(float), std::string_view>>({
{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<glm::vec3, glm::vec3, glm::vec3, Arc>;
+using Pos3ToArc = std::tuple<glm::vec3, glm::vec3, glm::vec3, Arc>;
-BOOST_DATA_TEST_CASE(test_create_arc,
- boost::unit_test::data::make<pos3_to_arc>({
+BOOST_DATA_TEST_CASE(TestCreateArc,
+ boost::unit_test::data::make<Pos3ToArc>({
{{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<glm::vec2, float, glm::vec2, float, glm::vec2, bool>;
+using FindArcCentreData = std::tuple<glm::vec2, float, glm::vec2, float, glm::vec2, bool>;
-BOOST_DATA_TEST_CASE(test_find_arc_centre,
- boost::unit_test::data::make<fac>({
+BOOST_DATA_TEST_CASE(TestFindArcCentre,
+ boost::unit_test::data::make<FindArcCentreData>({
{{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<Node>(GlobalPosition3D {}), vector_yaw(v)}, {std::make_shared<Node>(v), vector_yaw(-v)},
- glm::length(v)}
+namespace {
+ struct TestLinkStraight : public LinkStraight {
+ explicit TestLinkStraight(glm::vec3 entryVector) :
+ Link {{.node = std::make_shared<Node>(GlobalPosition3D {}), .dir = vector_yaw(entryVector)},
+ {.node = std::make_shared<Node>(entryVector), .dir = vector_yaw(-entryVector)},
+ glm::length(entryVector)}
+ {
+ }
+ };
+
+ using StraightsData = std::tuple<glm::vec3, float /*angFor*/, float /* angBack*/>;
+
+ struct TestLinkCurve : public LinkCurve {
+ explicit TestLinkCurve(glm::vec3 startPos, glm::vec3 endPos, glm::vec3 ctr) :
+ Link {{.node = std::make_shared<Node>(startPos), .dir = normalize(vector_yaw(ctr - startPos) - half_pi)},
+ {.node = std::make_shared<Node>(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<GlobalPosition3D /*e1*/, GlobalPosition3D /*ctr*/, Angle /*angFor*/, Angle /* angBack*/>;
+
+ template<typename T = float>
+ 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<glm::vec3, float /*angFor*/, float /* angBack*/>;
+}
-BOOST_DATA_TEST_CASE(straight1,
+BOOST_DATA_TEST_CASE(Straight1,
boost::unit_test::data::make<StraightsData>({
{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<Node>(e0), normalize(vector_yaw(ctr - e0) - half_pi)},
- {std::make_shared<Node>(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<GlobalPosition3D /*e1*/, GlobalPosition3D /*ctr*/, Angle /*angFor*/, Angle /* angBack*/>;
-
-BOOST_DATA_TEST_CASE(curve1,
+BOOST_DATA_TEST_CASE(Curve1,
boost::unit_test::data::make<CurvesData>({
{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<typename T = float>
-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<RelativePosition3D>(c, direction).distanceToLine(n1, n2), 0.01F);
+ const auto target = node1 + (along * nstep);
+ const auto direction = glm::normalize(target - origin);
+ BOOST_CHECK_LE(Ray<RelativePosition3D>(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<GlobalPosition2D, Angle>;
using ArcLineIntersectData = std::tuple<GlobalPosition2D, GlobalPosition2D, GlobalPosition2D, GlobalPosition2D,
GlobalPosition2D, std::optional<ArcLineIntersectExp>>;
-BOOST_DATA_TEST_CASE(arcline_intersection,
+BOOST_DATA_TEST_CASE(ArclineIntersection,
boost::unit_test::data::make<ArcLineIntersectData>({
{{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<TestLinkS> & 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<TestLinkS> & network, const Node::Ptr & nodeA, const Node::Ptr & nodeB) :
+ TestLinkS {network, nodeA, nodeB, (nodeA->pos - nodeB->pos)}
+ {
+ }
- TestLinkS(NetworkLinkHolder<TestLinkS> &, Node::Ptr a, Node::Ptr b, RelativePosition2D l) :
- Link {{std::move(a), 0}, {std::move(b), pi}, glm::length(l)}
- {
- }
+ TestLinkS(NetworkLinkHolder<TestLinkS> &, 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<TestLinkS> &, Node::Ptr a, Node::Ptr b, float l) :
- Link {{std::move(a), 0}, {std::move(b), pi}, l}
- {
- }
-};
+ TestLinkS(NetworkLinkHolder<TestLinkS> &, 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<TestLinkS>::NetworkLinkHolder() = default;
-struct TestNetwork : public NetworkOf<TestLink, TestLinkS> {
- TestNetwork() : NetworkOf<TestLink, TestLinkS> {RESDIR "rails.jpg"}
- {
- // 0 1 2
- // p000 <-> p100 <-> p200 <-> p300
- // \ | /
- // \ 5 /
- // 3 | 4
- // \-> p110 <-/
- addLink<TestLinkS>(p000, p100, 1.F);
- addLink<TestLinkS>(p100, p200, 1.F);
- addLink<TestLinkS>(p200, p300, 1.F);
- addLink<TestLinkS>(p000, p110, 2.F);
- addLink<TestLinkS>(p200, p110, 2.F);
- addLink<TestLinkS>(p100, p110, 1.F);
- }
+namespace {
+ struct TestNetwork : public NetworkOf<TestLink, TestLinkS> {
+ TestNetwork() : NetworkOf<TestLink, TestLinkS> {RESDIR "rails.jpg"}
+ {
+ // 0 1 2
+ // p000 <-> p100 <-> p200 <-> p300
+ // \ | /
+ // \ 5 /
+ // 3 | 4
+ // \-> p110 <-/
+ addLink<TestLinkS>(P000, P100, 1.F);
+ addLink<TestLinkS>(P100, P200, 1.F);
+ addLink<TestLinkS>(P200, P300, 1.F);
+ addLink<TestLinkS>(P000, P110, 2.F);
+ addLink<TestLinkS>(P200, P110, 2.F);
+ addLink<TestLinkS>(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<GlobalPosition3D>({
- p000,
- p100,
- p200,
- p300,
-});
-const auto INVALID_NODES = boost::unit_test::data::make<GlobalPosition3D>({
- {1000, 0, 0},
- {0, 1000, 0},
- {0, 0, 1000},
-});
+ RelativeDistance
+ getBaseWidth() const override
+ {
+ return 5'700;
+ }
+ };
+
+ constexpr auto VALID_NODES = std::array<GlobalPosition3D, 4>({
+ P000,
+ P100,
+ P200,
+ P300,
+ });
+ constexpr auto INVALID_NODES = std::array<GlobalPosition3D, 3>({
+ {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<RailLinkStraight *>(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<RailLinkStraight *>(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<RailLinkStraight *>(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<RailLinkCurve *>(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<RailLinkStraight *>(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<RailLinkStraight *>(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<RailLinkStraight *>(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<RailLinkCurve *>(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<RailLinkCurve *>(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<RailLinkCurve *>(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<int, std::vector>;
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 <tuple>
#include <vector>
-struct JPP {
- template<typename T>
- T
- load_json(const std::filesystem::path & path)
- {
- BOOST_TEST_CONTEXT(path) {
- std::ifstream ss {path};
- auto to = Persistence::JsonParsePersistence {}.loadState<T>(ss);
- BOOST_REQUIRE(to);
- return to;
+namespace {
+ struct JPP {
+ template<typename T>
+ T
+ loadJson(const std::filesystem::path & path)
+ {
+ BOOST_TEST_CONTEXT(path) {
+ std::ifstream inputStream {path};
+ auto object = Persistence::JsonParsePersistence {}.loadState<T>(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<std::filesystem::path>
+ fixturesIn(const std::filesystem::path & root)
+ {
+ return {std::filesystem::directory_iterator {root}, {}};
}
-};
-
-BOOST_FIXTURE_TEST_CASE(load_object, JPP)
-{
- auto to = load_json<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::filesystem::path>
-fixtures_in(const std::filesystem::path & root)
+BOOST_FIXTURE_TEST_CASE(LoadEmptyObject, JPP)
{
- return {std::filesystem::directory_iterator {root}, {}};
+ auto object = loadJson<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(path), std::runtime_error);
+ BOOST_CHECK_THROW(loadJson<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(FIXTURESDIR "json/bad_type.json"), std::out_of_range);
+ BOOST_CHECK_THROW(loadJson<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<SubObject *>(to->aptr.get());
- BOOST_REQUIRE(s);
- BOOST_CHECK_EQUAL(s->sub, "set sub");
+ auto object = loadJson<std::unique_ptr<TestObject>>(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<SubObject *>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(FIXTURESDIR "json/shared_ptr_wrong_type.json"),
+ BOOST_CHECK_THROW(loadJson<std::unique_ptr<SharedTestObject>>(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<std::unique_ptr<SharedTestObject>>(FIXTURESDIR "json/shared_ptr_null.json");
- BOOST_CHECK(to->sptr);
- BOOST_CHECK(!to->ssptr);
+ auto object = loadJson<std::unique_ptr<SharedTestObject>>(FIXTURESDIR "json/shared_ptr_null.json");
+ BOOST_CHECK(object->sptr);
+ BOOST_CHECK(!object->ssptr);
}
-using svs = std::tuple<const char * const, std::string_view>;
-auto const TEST_STRINGS = boost::unit_test::data::make<svs>({
+using InputStringAndExpected = std::tuple<const char * const, std::string_view>;
+auto const TEST_STRINGS = boost::unit_test::data::make<InputStringAndExpected>({
{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<svs>({
{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<svs>({
+auto const TEST_STRINGS_DECODE_ONLY = boost::unit_test::data::make<InputStringAndExpected>({
{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<svs>({
{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<std::string>(str), exp);
}
-using cpstr = std::tuple<unsigned long, std::string_view>;
+using CodePointAndString = std::tuple<unsigned long, std::string_view>;
-BOOST_DATA_TEST_CASE(utf8_decode,
- boost::unit_test::data::make<cpstr>({
+BOOST_DATA_TEST_CASE(Utf8Decode,
+ boost::unit_test::data::make<CodePointAndString>({
{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<unsigned long>({0xd800, 0xdfff, 0x110000}), cp)
+BOOST_DATA_TEST_CASE(Utf8DecodeBad, boost::unit_test::data::make<unsigned long>({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<TestObject> to {};
- std::stringstream ss;
- Persistence::JsonWritePersistence {ss}.saveState(to);
- BOOST_CHECK_EQUAL(ss.str(), "null");
+ std::unique_ptr<TestObject> 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<TestObject>();
- std::stringstream ss;
- Persistence::JsonWritePersistence {ss}.saveState(to);
- BOOST_CHECK_EQUAL(ss.str(),
+ auto object = std::make_unique<TestObject>();
+ 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<std::unique_ptr<TestObject>>(FIXTURESDIR "json/load_object.json");
- std::stringstream ss;
- Persistence::JsonWritePersistence {ss}.saveState(to);
- BOOST_CHECK_EQUAL(ss.str(),
+ auto object = loadJson<std::unique_ptr<TestObject>>(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<std::unique_ptr<TestObject>>(FIXTURESDIR "json/abs.json");
- std::stringstream ss;
- Persistence::JsonWritePersistence {ss}.saveState(to);
- BOOST_CHECK_EQUAL(ss.str(),
+ auto object = loadJson<std::unique_ptr<TestObject>>(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<std::unique_ptr<SharedTestObject>>(FIXTURESDIR "json/shared_ptr_same.json");
- std::stringstream ss;
+ auto object = loadJson<std::unique_ptr<SharedTestObject>>(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<decltype(ptr)>(&so));
+ BOOST_TEST_CONTEXT(subObjectId) {
+ auto ptr = std::stoul(subObjectId, nullptr, 16);
+ // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+ BOOST_CHECK_EQUAL(ptr, reinterpret_cast<decltype(ptr)>(&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 <ui/applicationBase.h>
#include <ui/window.h>
-class TestScene : public SceneProvider {
- RailVehicleClassPtr brush47rvc;
- std::shared_ptr<RailVehicle> train1, train2;
- RailLinks rail;
- std::shared_ptr<Environment> env = std::make_shared<Environment>();
-
- std::shared_ptr<Terrain> terrain = std::make_shared<Terrain>(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<RailVehicleClass>();
- std::random_device randomdev {};
- std::uniform_real_distribution<Angle> rotationDistribution {0, two_pi};
- std::uniform_int_distribution<GlobalDistance> positionOffsetDistribution {-1500, +1500};
- std::uniform_int_distribution<int> treeDistribution {1, 3};
- std::uniform_int_distribution<int> treeVariantDistribution {1, 4};
- train1 = std::make_shared<RailVehicle>(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<RailVehicle>(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<Plant>(gameState->assets
- .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev),
- treeVariantDistribution(randomdev)))
- .dynamicCast<Foliage>(),
- Location {{x + positionOffsetDistribution(randomdev), y + positionOffsetDistribution(randomdev),
- 1},
- {0, rotationDistribution(randomdev), 0}});
+namespace {
+ class TestScene : public SceneProvider {
+ RailVehicleClassPtr brush47rvc;
+ std::shared_ptr<RailVehicle> train1, train2;
+ RailLinks rail;
+ std::shared_ptr<Environment> env = std::make_shared<Environment>();
+
+ std::shared_ptr<Terrain> terrain
+ = std::make_shared<Terrain>(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<RailVehicleClass>();
+ std::random_device randomdev {};
+ std::uniform_real_distribution<Angle> rotationDistribution {0, two_pi};
+ std::uniform_int_distribution<GlobalDistance> positionOffsetDistribution {-1500, +1500};
+ std::uniform_int_distribution<int> treeDistribution {1, 3};
+ std::uniform_int_distribution<int> treeVariantDistribution {1, 4};
+ train1 = std::make_shared<RailVehicle>(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<RailVehicle>(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<Plant>(
+ gameState->assets
+ .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev),
+ treeVariantDistribution(randomdev)))
+ .dynamicCast<Foliage>(),
+ 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<const Renderable>()) {
- 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<const Renderable>()) {
- 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<const Renderable>()) {
+ 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<const Renderable>()) {
+ 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> 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<std::array<char, 1>>);
static_assert(!NonStringIterableCollection<std::string>);
static_assert(!NonStringIterableCollection<std::string_view>);
-static_assert(requires(std::vector<int> i, std::ostream & o) { o << i; });
-static_assert(requires(std::array<int, 10> i, std::ostream & o) { o << i; });
-static_assert(requires(std::set<int> i, std::ostream & o) { o << i; });
-static_assert(requires(std::map<int, int> i, std::ostream & o) { o << i; });
+static_assert(requires(std::vector<int> input, std::ostream & strm) { strm << input; });
+static_assert(requires(std::array<int, 10> input, std::ostream & strm) { strm << input; });
+static_assert(requires(std::set<int> input, std::ostream & strm) { strm << input; });
+static_assert(requires(std::map<int, int> 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 <stream_support.h>
#include "testMainWindow.h"
-#include "testRenderOutput.h"
#include <array>
#include <gfx/models/texture.h>
#include <glm/glm.hpp>
@@ -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<uint32_t> 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<unsigned, unsigned, unsigned>;
-BOOST_DATA_TEST_CASE(fontTextureSize, boost::unit_test::data::make<unsigned>({2, 3, 10, 50, 250}), fontHeight)
+BOOST_DATA_TEST_CASE(FontTextureSize, boost::unit_test::data::make<unsigned>({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<unsigned>({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<decltype(get_codepoint(nullptr)), Font::CharData>;
-BOOST_DATA_TEST_CASE(initialize_chardata_A,
+BOOST_DATA_TEST_CASE(InitializeCharDataA,
boost::unit_test::data::make<CharDataTest>({
{'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::size_t>(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::size_t>(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 <boost/test/unit_test.hpp>
#include <set>
#include <stream_support.h>
#include <worker.h>
-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<Worker::WorkPtrT<uint32_t>> ps;
+ std::vector<Worker::WorkPtrT<uint32_t>> jobs;
for (int i {}; i < 30; ++i) {
- ps.push_back(Worker::addWork(workCounter));
+ jobs.emplace_back(Worker::addWork(workCounter));
}
std::set<uint32_t> 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<uint32_t>::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<Worker::WorkPtrT<uint32_t>> ps;
+ std::vector<Worker::WorkPtrT<uint32_t>> 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<Worker::WorkPtrT<uint32_t>> ps;
+ std::vector<Worker::WorkPtrT<uint32_t>> jobs;
for (int i {}; i < 30; ++i) {
- ps.push_back(Worker::addWork(recurse));
+ jobs.emplace_back(Worker::addWork(recurse));
}
std::set<uint32_t> 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<uint32_t>::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<typename T>
decltype(auto)
loadFixtureJson(const std::filesystem::path & path)
{
- std::ifstream in {FIXTURESDIR / path};
- return Persistence::JsonParsePersistence {}.loadState<std::vector<T>>(in);
+ std::ifstream inputStream {FIXTURESDIR / path};
+ return Persistence::JsonParsePersistence {}.loadState<std::vector<T>>(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 <gl_traits.h>
#include <stdexcept>
-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 {};
generated by cgit v1.2.3 (git 2.46.0) at 2025-05-09 09:53:57 +0000