Fix all warnings in performance tests

5 files changed, 82 insertions, 77 deletions

diff --git a/test/perf-assetFactory.cpp b/test/perf-assetFactory.cpp
index 671713c..0f7895b 100644
--- a/test/perf-assetFactory.cpp
+++ b/test/perf-assetFactory.cpp
@@ -2,27 +2,29 @@
 #include "testMainWindow.h"
 #include <benchmark/benchmark.h>
 
-static void
-brush47xml_load(benchmark::State & state)
-{
-	TestMainWindowAppBase window;
+namespace {
+	void
+	brush47xmlLoad(benchmark::State & state)
+	{
+		TestMainWindowAppBase window;
 
-	for (auto _ : state) {
-		benchmark::DoNotOptimize(AssetFactory::loadXML(RESDIR "/brush47.xml"));
+		for (auto loop : state) {
+			benchmark::DoNotOptimize(AssetFactory::loadXML(RESDIR "/brush47.xml"));
+		}
 	}
-}
 
-static void
-foliagexml_load(benchmark::State & state)
-{
-	TestMainWindowAppBase window;
+	void
+	foliagexmlLoad(benchmark::State & state)
+	{
+		TestMainWindowAppBase window;
 
-	for (auto _ : state) {
-		benchmark::DoNotOptimize(AssetFactory::loadXML(RESDIR "/foliage.xml"));
+		for (auto loop : state) {
+			benchmark::DoNotOptimize(AssetFactory::loadXML(RESDIR "/foliage.xml"));
+		}
 	}
 }
 
-BENCHMARK(brush47xml_load);
-BENCHMARK(foliagexml_load);
+BENCHMARK(brush47xmlLoad);
+BENCHMARK(foliagexmlLoad);
 
 BENCHMARK_MAIN();
diff --git a/test/perf-geoData.cpp b/test/perf-geoData.cpp
index d9ea8c6..4eff357 100644
--- a/test/perf-geoData.cpp
+++ b/test/perf-geoData.cpp
@@ -2,56 +2,56 @@
 #include <game/geoData.h>
 
 namespace {
-	const GeoData tm {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")};
+	const GeoData geoDataFixture {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")};
 
 	void
-	terrain_findPoint(benchmark::State & state)
+	terrainFindPoint(benchmark::State & state)
 	{
-		for (auto _ : state) {
-			benchmark::DoNotOptimize(tm.findPoint({315555000, 495556000}));
+		for (auto loop : state) {
+			benchmark::DoNotOptimize(geoDataFixture.findPoint({315555000, 495556000}));
 		}
 	}
 
 	void
-	terrain_walk(benchmark::State & state)
+	terrainWalk(benchmark::State & state)
 	{
 		const glm::vec2 point {310001000, 490000000};
-		const GeoData::PointFace start {point, tm.findPoint(point)};
-		for (auto _ : state) {
-			tm.walk(start, {319999000, 500000000}, [](auto f) {
-				benchmark::DoNotOptimize(f);
+		const GeoData::PointFace start {point, geoDataFixture.findPoint(point)};
+		for (auto loop : state) {
+			geoDataFixture.walk(start, {319999000, 500000000}, [](auto step) {
+				benchmark::DoNotOptimize(step);
 			});
 		}
 	}
 
 	void
-	terrain_walkBoundary(benchmark::State & state)
+	terrainWalkBoundary(benchmark::State & state)
 	{
-		for (auto _ : state) {
-			tm.boundaryWalk([](auto heh) {
+		for (auto loop : state) {
+			geoDataFixture.boundaryWalk([](auto heh) {
 				benchmark::DoNotOptimize(heh);
 			});
 		}
 	}
 
 	void
-	terrain_deform(benchmark::State & state)
+	terrainDeform(benchmark::State & state)
 	{
 		std::array<GlobalPosition3D, 3> points {{
 				{315555000, 495556000, 0},
 				{315655000, 495556000, 0},
 				{315655000, 495557000, 0},
 		}};
-		for (auto _ : state) {
-			auto geoData {tm};
+		for (auto loop : state) {
+			auto geoData {geoDataFixture};
 			benchmark::DoNotOptimize(geoData.setHeights(points, GeoData::SetHeightsOpts {.surface = nullptr}));
 		}
 	}
 }
 
-BENCHMARK(terrain_findPoint);
-BENCHMARK(terrain_walk);
-BENCHMARK(terrain_walkBoundary);
-BENCHMARK(terrain_deform);
+BENCHMARK(terrainFindPoint);
+BENCHMARK(terrainWalk);
+BENCHMARK(terrainWalkBoundary);
+BENCHMARK(terrainDeform);
 
 BENCHMARK_MAIN();
diff --git a/test/perf-instancing.cpp b/test/perf-instancing.cpp
index 3638111..a56d60e 100644
--- a/test/perf-instancing.cpp
+++ b/test/perf-instancing.cpp
@@ -3,38 +3,41 @@
 #include <benchmark/benchmark.h>
 #include <random>
 
-struct Instance {
-	GlobalPosition3D pos;
-	glm::mat3 rot;
-};
+namespace {
+	struct Instance {
+		GlobalPosition3D pos;
+		glm::mat3 rot;
+	};
 
-struct data {
-	explicit data(size_t n)
-	{
-		std::mt19937 gen(std::random_device {}());
-		std::uniform_int_distribution<GlobalDistance> xy(0, 1000000);
-		std::uniform_int_distribution<GlobalDistance> z(0, 10000);
-		while (n--) {
-			proxies.emplace_back(instances.acquire(GlobalPosition3D {xy(gen), xy(gen), z(gen)}, glm::mat3 {}));
+	struct Data {
+		explicit Data(size_t n)
+		{
+			std::mt19937 gen(std::random_device {}());
+			std::uniform_int_distribution<GlobalDistance> xyDistrib(0, 1000000);
+			std::uniform_int_distribution<GlobalDistance> zDistrib(0, 10000);
+			while (n--) {
+				proxies.emplace_back(instances.acquire(
+						GlobalPosition3D {xyDistrib(gen), xyDistrib(gen), zDistrib(gen)}, glm::mat3 {}));
+			}
 		}
-	}
 
-	InstanceVertices<Instance> instances;
-	std::vector<InstanceVertices<Instance>::InstanceProxy> proxies;
-};
+		InstanceVertices<Instance> instances;
+		std::vector<InstanceVertices<Instance>::InstanceProxy> proxies;
+	};
 
-static void
-partition(benchmark::State & state)
-{
-	TestMainWindowAppBase window;
-	data d(static_cast<size_t>(state.range()));
-	GlobalPosition2D pos {};
-	for (auto _ : state) {
-		d.instances.partition([&pos](const auto & i) {
-			return std::abs(i.pos.x - pos.x) < 5 && std::abs(i.pos.y - pos.y) < 5;
-		});
-		pos += GlobalPosition2D {33, 17};
-		pos %= 1000000;
+	void
+	partition(benchmark::State & state)
+	{
+		TestMainWindowAppBase window;
+		Data data(static_cast<size_t>(state.range()));
+		GlobalPosition2D pos {};
+		for (auto loop : state) {
+			data.instances.partition([&pos](const auto & instance) {
+				return std::abs(instance.pos.x - pos.x) < 5 && std::abs(instance.pos.y - pos.y) < 5;
+			});
+			pos += GlobalPosition2D {33, 17};
+			pos %= 1000000;
+		}
 	}
 }
 
diff --git a/test/perf-persistence.cpp b/test/perf-persistence.cpp
index 2e099bf..a39b0ba 100644
--- a/test/perf-persistence.cpp
+++ b/test/perf-persistence.cpp
@@ -1,23 +1,24 @@
 #include "lib/jsonParse-persistence.h"
-#include "testMainWindow.h"
 #include "testStructures.h"
 #include <benchmark/benchmark.h>
 
-template<typename T>
-static void
-parse_load_object(benchmark::State & state, T &&, const char * path)
-{
-	for (auto _ : state) {
-		std::ifstream in {path};
-		benchmark::DoNotOptimize(Persistence::JsonParsePersistence {}.loadState<T>(in));
+namespace {
+	template<typename T>
+	void
+	parseLoadObject(benchmark::State & state, T &&, const char * path)
+	{
+		for (auto loop : state) {
+			std::ifstream inStrm {path};
+			benchmark::DoNotOptimize(Persistence::JsonParsePersistence {}.loadState<T>(inStrm));
+		}
 	}
 }
 
-BENCHMARK_CAPTURE(parse_load_object, load_object, std::unique_ptr<TestObject> {}, FIXTURESDIR "json/load_object.json");
-BENCHMARK_CAPTURE(parse_load_object, nested, std::unique_ptr<TestObject> {}, FIXTURESDIR "json/nested.json");
-BENCHMARK_CAPTURE(parse_load_object, shared_ptr_diff, std::unique_ptr<SharedTestObject> {},
+BENCHMARK_CAPTURE(parseLoadObject, load_object, std::unique_ptr<TestObject> {}, FIXTURESDIR "json/load_object.json");
+BENCHMARK_CAPTURE(parseLoadObject, nested, std::unique_ptr<TestObject> {}, FIXTURESDIR "json/nested.json");
+BENCHMARK_CAPTURE(parseLoadObject, shared_ptr_diff, std::unique_ptr<SharedTestObject> {},
 		FIXTURESDIR "json/shared_ptr_diff.json");
-BENCHMARK_CAPTURE(parse_load_object, shared_ptr_same, std::unique_ptr<SharedTestObject> {},
+BENCHMARK_CAPTURE(parseLoadObject, shared_ptr_same, std::unique_ptr<SharedTestObject> {},
 		FIXTURESDIR "json/shared_ptr_same.json");
 
 BENCHMARK_MAIN();
diff --git a/test/perf-terrain.cpp b/test/perf-terrain.cpp
index e75f80b..004e1af 100644
--- a/test/perf-terrain.cpp
+++ b/test/perf-terrain.cpp
@@ -1,6 +1,5 @@
 #include "game/terrain.h"
 #include "gfx/camera.h"
-#include "gfx/frustum.h"
 #include "gfx/gl/sceneShader.h"
 #include "testMainWindow.h"
 #include <benchmark/benchmark.h>
@@ -13,7 +12,7 @@ namespace {
 	{
 		Terrain terrain {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")};
 
-		for (auto _ : state) {
+		for (auto loop : state) {
 			terrain.generateMeshes();
 		}
 	}
@@ -26,7 +25,7 @@ namespace {
 		Camera cam {terrain.getExtents().min + GlobalPosition3D {0, 0, 10000}, 45.F, 1.F, 1, 10000};
 		cam.setForward(::north + ::east);
 
-		for (auto _ : state) {
+		for (auto loop : state) {
 			terrain.render(shader, cam);
 		}
 	}