Fix all warnings in test/HEADmain

1 files changed, 44 insertions, 47 deletions

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);
 }