From a2d7181700ac64b8e7a4472ec26dfa253b38f188 Mon Sep 17 00:00:00 2001
From: Lexi Winter <lexi@le-fay.org>
Date: Sat, 28 Jun 2025 19:25:55 +0100
Subject: split nihil into separate modules

---
 nihil.util/test_parse_size.cc | 168 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 168 insertions(+)
 create mode 100644 nihil.util/test_parse_size.cc

(limited to 'nihil.util/test_parse_size.cc')

diff --git a/nihil.util/test_parse_size.cc b/nihil.util/test_parse_size.cc
new file mode 100644
index 0000000..4f4d018
--- /dev/null
+++ b/nihil.util/test_parse_size.cc
@@ -0,0 +1,168 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <cstdint>
+#include <system_error>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil.core;
+import nihil.util;
+
+TEST_CASE("parse_size: empty value", "[nihil]")
+{
+	using namespace nihil;
+
+	auto n = parse_size<std::uint64_t>("");
+	REQUIRE(!n);
+	REQUIRE(n.error() == nihil::errc::empty_string);
+}
+
+TEST_CASE("parse_size: basic", "[nihil]")
+{
+	using namespace nihil;
+
+	SECTION("bare number") {
+		auto n = parse_size<std::uint64_t>("1024").value();
+		REQUIRE(n == 1024);
+	}
+
+	SECTION("max value, unsigned") {
+		auto n = parse_size<std::uint16_t>("65535").value();
+		REQUIRE(n == 65535);
+	}
+
+	SECTION("max value, signed") {
+		auto n = parse_size<std::uint16_t>("32767").value();
+		REQUIRE(n == 32767);
+	}
+
+	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") {
+		auto n = parse_size<std::int16_t>("32768");
+		REQUIRE(!n);
+		REQUIRE(n.error() == std::errc::result_out_of_range);
+	}
+
+	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") {
+		auto n = parse_size<std::int16_t>("100000");
+		REQUIRE(!n);
+		REQUIRE(n.error() == std::errc::result_out_of_range);
+	}
+}
+
+TEST_CASE("parse_size: invalid multiplier", "[nihil]")
+{
+	using namespace nihil;
+
+	auto n = parse_size<std::uint64_t>("4z");
+	REQUIRE(!n);
+	REQUIRE(n.error() == nihil::errc::invalid_unit);
+
+	n = parse_size<std::uint64_t>("4kz");
+	REQUIRE(!n);
+	REQUIRE(n.error() == nihil::errc::invalid_unit);
+}
+
+TEST_CASE("parse_size: multipliers", "[nihil]")
+{
+	using namespace nihil;
+
+	auto sf = static_cast<std::uint64_t>(4);
+
+	SECTION("k") {
+		auto n = parse_size<std::uint64_t>("4k").value();
+		REQUIRE(n == sf * 1024);
+	}
+
+	SECTION("m") {
+		auto n = parse_size<std::uint64_t>("4m").value();
+		REQUIRE(n == sf * 1024 * 1024);
+	}
+
+	SECTION("g") {
+		auto n = parse_size<std::uint64_t>("4g").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024);
+	}
+
+	SECTION("t") {
+		auto n = parse_size<std::uint64_t>("4t").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024);
+	}
+
+	SECTION("p") {
+		auto n = parse_size<std::uint64_t>("4p").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024 * 1024);
+	}
+}
+
+TEST_CASE("parse_size: multiplier overflow", "[nihil]")
+{
+	using namespace nihil;
+
+	SECTION("signed") {
+		auto n = parse_size<std::uint16_t>("64k");
+		REQUIRE(!n);
+		REQUIRE(n.error() == std::errc::result_out_of_range);
+	}
+
+	SECTION("unsigned") {
+		auto n = parse_size<std::int16_t>("32k");
+		REQUIRE(!n);
+		REQUIRE(n.error() == std::errc::result_out_of_range);
+	}
+}
+
+TEST_CASE("parse_size: wide", "[nihil]")
+{
+	using namespace nihil;
+
+	SECTION("bare number") {
+		auto n = parse_size<std::uint64_t>(L"1024").value();
+		REQUIRE(n == 1024);
+	}
+}
+
+TEST_CASE("parse_size: wide multipliers", "[nihil]")
+{
+	using namespace nihil;
+
+	auto sf = static_cast<std::uint64_t>(4);
+
+	SECTION("k") {
+		auto n = parse_size<std::uint64_t>(L"4k").value();
+		REQUIRE(n == sf * 1024);
+	}
+
+	SECTION("m") {
+		auto n = parse_size<std::uint64_t>(L"4m").value();
+		REQUIRE(n == sf * 1024 * 1024);
+	}
+
+	SECTION("g") {
+		auto n = parse_size<std::uint64_t>(L"4g").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024);
+	}
+
+	SECTION("t") {
+		auto n = parse_size<std::uint64_t>(L"4t").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024);
+	}
+
+	SECTION("p") {
+		auto n = parse_size<std::uint64_t>(L"4p").value();
+		REQUIRE(n == sf * 1024 * 1024 * 1024 * 1024 * 1024);
+	}
+}
-- 
cgit v1.2.3