From 2e2d1bd3b6c7776b77c33b94f30ead89367a71e6 Mon Sep 17 00:00:00 2001
From: Lexi Winter <lexi@le-fay.org>
Date: Tue, 1 Jul 2025 17:07:04 +0100
Subject: add nihil.std

---
 nihil.util/parse_size.test.cc | 165 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 165 insertions(+)
 create mode 100644 nihil.util/parse_size.test.cc

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

diff --git a/nihil.util/parse_size.test.cc b/nihil.util/parse_size.test.cc
new file mode 100644
index 0000000..d79912a
--- /dev/null
+++ b/nihil.util/parse_size.test.cc
@@ -0,0 +1,165 @@
+// This source code is released into the public domain.
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil.std;
+import nihil.core;
+import nihil.error;
+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