From 06fafff8e9e9c096cc39bde0306caa53ad3a2351 Mon Sep 17 00:00:00 2001
From: Lexi Winter <lexi@le-fay.org>
Date: Wed, 2 Jul 2025 03:43:39 +0100
Subject: move error and match to util

---
 nihil.util/parse_size.test.cc | 43 ++++++++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 21 deletions(-)

(limited to 'nihil.util/parse_size.test.cc')

diff --git a/nihil.util/parse_size.test.cc b/nihil.util/parse_size.test.cc
index d79912a..ee97996 100644
--- a/nihil.util/parse_size.test.cc
+++ b/nihil.util/parse_size.test.cc
@@ -4,9 +4,9 @@
 
 import nihil.std;
 import nihil.core;
-import nihil.error;
 import nihil.util;
 
+namespace {
 TEST_CASE("parse_size: empty value", "[nihil]")
 {
 	using namespace nihil;
@@ -20,40 +20,40 @@ TEST_CASE("parse_size: basic", "[nihil]")
 {
 	using namespace nihil;
 
-	SECTION("bare number") {
+	SECTION ("bare number") {
 		auto n = parse_size<std::uint64_t>("1024").value();
 		REQUIRE(n == 1024);
 	}
 
-	SECTION("max value, unsigned") {
+	SECTION ("max value, unsigned") {
 		auto n = parse_size<std::uint16_t>("65535").value();
 		REQUIRE(n == 65535);
 	}
 
-	SECTION("max value, signed") {
+	SECTION ("max value, signed") {
 		auto n = parse_size<std::uint16_t>("32767").value();
 		REQUIRE(n == 32767);
 	}
 
-	SECTION("overflow by 1, unsigned") {
+	SECTION ("overflow by 1, unsigned") {
 		auto n = parse_size<std::uint16_t>("65536");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
 	}
 
-	SECTION("overflow by 1, signed") {
+	SECTION ("overflow by 1, signed") {
 		auto n = parse_size<std::int16_t>("32768");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
 	}
 
-	SECTION("overflow by many, unsigned") {
+	SECTION ("overflow by many, unsigned") {
 		auto n = parse_size<std::uint16_t>("100000");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
 	}
 
-	SECTION("overflow by many, signed") {
+	SECTION ("overflow by many, signed") {
 		auto n = parse_size<std::int16_t>("100000");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
@@ -79,27 +79,27 @@ TEST_CASE("parse_size: multipliers", "[nihil]")
 
 	auto sf = static_cast<std::uint64_t>(4);
 
-	SECTION("k") {
+	SECTION ("k") {
 		auto n = parse_size<std::uint64_t>("4k").value();
 		REQUIRE(n == sf * 1024);
 	}
 
-	SECTION("m") {
+	SECTION ("m") {
 		auto n = parse_size<std::uint64_t>("4m").value();
 		REQUIRE(n == sf * 1024 * 1024);
 	}
 
-	SECTION("g") {
+	SECTION ("g") {
 		auto n = parse_size<std::uint64_t>("4g").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024);
 	}
 
-	SECTION("t") {
+	SECTION ("t") {
 		auto n = parse_size<std::uint64_t>("4t").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024);
 	}
 
-	SECTION("p") {
+	SECTION ("p") {
 		auto n = parse_size<std::uint64_t>("4p").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024 * 1024);
 	}
@@ -109,13 +109,13 @@ TEST_CASE("parse_size: multiplier overflow", "[nihil]")
 {
 	using namespace nihil;
 
-	SECTION("signed") {
+	SECTION ("signed") {
 		auto n = parse_size<std::uint16_t>("64k");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
 	}
 
-	SECTION("unsigned") {
+	SECTION ("unsigned") {
 		auto n = parse_size<std::int16_t>("32k");
 		REQUIRE(!n);
 		REQUIRE(n.error() == std::errc::result_out_of_range);
@@ -126,7 +126,7 @@ TEST_CASE("parse_size: wide", "[nihil]")
 {
 	using namespace nihil;
 
-	SECTION("bare number") {
+	SECTION ("bare number") {
 		auto n = parse_size<std::uint64_t>(L"1024").value();
 		REQUIRE(n == 1024);
 	}
@@ -138,28 +138,29 @@ TEST_CASE("parse_size: wide multipliers", "[nihil]")
 
 	auto sf = static_cast<std::uint64_t>(4);
 
-	SECTION("k") {
+	SECTION ("k") {
 		auto n = parse_size<std::uint64_t>(L"4k").value();
 		REQUIRE(n == sf * 1024);
 	}
 
-	SECTION("m") {
+	SECTION ("m") {
 		auto n = parse_size<std::uint64_t>(L"4m").value();
 		REQUIRE(n == sf * 1024 * 1024);
 	}
 
-	SECTION("g") {
+	SECTION ("g") {
 		auto n = parse_size<std::uint64_t>(L"4g").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024);
 	}
 
-	SECTION("t") {
+	SECTION ("t") {
 		auto n = parse_size<std::uint64_t>(L"4t").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024);
 	}
 
-	SECTION("p") {
+	SECTION ("p") {
 		auto n = parse_size<std::uint64_t>(L"4p").value();
 		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024 * 1024);
 	}
 }
+} // anonymous namespace
-- 
cgit v1.2.3