summaryrefslogtreecommitdiff
path: root/test/test-geoData.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/test-geoData.cpp')
-rw-r--r--test/test-geoData.cpp151
1 files changed, 77 insertions, 74 deletions
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}));
}
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-05-10 05:10:16 +0000