From d27d1302d1fa1b96bf8f53f17fce947f19d21330 Mon Sep 17 00:00:00 2001
From: Lexi Winter <lexi@le-fay.org>
Date: Sat, 21 Jun 2025 17:18:57 +0100
Subject: add nihil.config (incomplete)

---
 CMakeLists.txt                |  19 ++-
 nihil.config/CMakeLists.txt   |  11 ++
 nihil.config/error.ccm        |  26 +++
 nihil.config/nihil.config.ccm |  12 ++
 nihil.config/option.ccm       |  84 ++++++++++
 nihil.config/store.ccm        | 183 +++++++++++++++++++++
 nihil.config/string.ccm       |  54 ++++++
 nihil.ucl/CMakeLists.txt      |  13 ++
 nihil.ucl/nihil.ucl.ccm       |   9 +
 nihil/CMakeLists.txt          |   5 +
 nihil/tests/CMakeLists.txt    |  25 +++
 nihil/tests/command_map.cc    |  41 +++++
 nihil/tests/ctype.cc          | 373 ++++++++++++++++++++++++++++++++++++++++++
 nihil/tests/fd.cc             | 200 ++++++++++++++++++++++
 nihil/tests/generator.cc      |  56 +++++++
 nihil/tests/generic_error.cc  |  17 ++
 nihil/tests/getenv.cc         |  48 ++++++
 nihil/tests/guard.cc          |  20 +++
 nihil/tests/next_word.cc      |  65 ++++++++
 nihil/tests/skipws.cc         |  45 +++++
 nihil/tests/spawn.cc          |  65 ++++++++
 nihil/tests/tabulate.cc       |  75 +++++++++
 tests/CMakeLists.txt          |  25 ---
 tests/command_map.cc          |  41 -----
 tests/ctype.cc                | 373 ------------------------------------------
 tests/fd.cc                   | 200 ----------------------
 tests/generator.cc            |  56 -------
 tests/generic_error.cc        |  17 --
 tests/getenv.cc               |  48 ------
 tests/guard.cc                |  20 ---
 tests/next_word.cc            |  65 --------
 tests/skipws.cc               |  45 -----
 tests/spawn.cc                |  65 --------
 tests/tabulate.cc             |  75 ---------
 34 files changed, 1444 insertions(+), 1032 deletions(-)
 create mode 100644 nihil.config/CMakeLists.txt
 create mode 100644 nihil.config/error.ccm
 create mode 100644 nihil.config/nihil.config.ccm
 create mode 100644 nihil.config/option.ccm
 create mode 100644 nihil.config/store.ccm
 create mode 100644 nihil.config/string.ccm
 create mode 100644 nihil.ucl/CMakeLists.txt
 create mode 100644 nihil.ucl/nihil.ucl.ccm
 create mode 100644 nihil/tests/CMakeLists.txt
 create mode 100644 nihil/tests/command_map.cc
 create mode 100644 nihil/tests/ctype.cc
 create mode 100644 nihil/tests/fd.cc
 create mode 100644 nihil/tests/generator.cc
 create mode 100644 nihil/tests/generic_error.cc
 create mode 100644 nihil/tests/getenv.cc
 create mode 100644 nihil/tests/guard.cc
 create mode 100644 nihil/tests/next_word.cc
 create mode 100644 nihil/tests/skipws.cc
 create mode 100644 nihil/tests/spawn.cc
 create mode 100644 nihil/tests/tabulate.cc
 delete mode 100644 tests/CMakeLists.txt
 delete mode 100644 tests/command_map.cc
 delete mode 100644 tests/ctype.cc
 delete mode 100644 tests/fd.cc
 delete mode 100644 tests/generator.cc
 delete mode 100644 tests/generic_error.cc
 delete mode 100644 tests/getenv.cc
 delete mode 100644 tests/guard.cc
 delete mode 100644 tests/next_word.cc
 delete mode 100644 tests/skipws.cc
 delete mode 100644 tests/spawn.cc
 delete mode 100644 tests/tabulate.cc

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9df3b46..457f603 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,8 +4,14 @@ cmake_minimum_required(VERSION 3.28)
 
 project(libexi)
 
+option(NIHIL_CONFIG	"Build the nihil.config library"	ON)
+option(NIHIL_UCL	"Build the nihil.ucl library"		ON)
+option(NIHIL_TESTS	"Build nihil's unit tests"		ON)
+
 set(CMAKE_CXX_STANDARD 26)
 
+find_package(PkgConfig REQUIRED)
+
 add_compile_options(-W)
 add_compile_options(-Wall)
 add_compile_options(-Wextra)
@@ -13,6 +19,15 @@ add_compile_options(-Werror)
 add_compile_options(-Wpedantic)
 
 add_subdirectory(nihil)
-add_subdirectory(tests)
 
-enable_testing()
+if(NIHIL_UCL)
+	add_subdirectory(nihil.ucl)
+endif()
+
+if(NIHIL_CONFIG)
+	add_subdirectory(nihil.config)
+endif()
+
+if(NIHIL_TESTS)
+	enable_testing()
+endif()
diff --git a/nihil.config/CMakeLists.txt b/nihil.config/CMakeLists.txt
new file mode 100644
index 0000000..d96b116
--- /dev/null
+++ b/nihil.config/CMakeLists.txt
@@ -0,0 +1,11 @@
+# This source code is released into the public domain.
+
+add_library(nihil.config STATIC)
+target_sources(nihil.config PUBLIC
+	FILE_SET modules TYPE CXX_MODULES FILES
+	nihil.config.ccm
+	error.ccm
+	store.ccm
+	option.ccm
+	string.ccm)
+target_link_libraries(nihil.config PUBLIC nihil nihil.ucl)
diff --git a/nihil.config/error.ccm b/nihil.config/error.ccm
new file mode 100644
index 0000000..0da91cb
--- /dev/null
+++ b/nihil.config/error.ccm
@@ -0,0 +1,26 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+#include <format>
+#include <utility>
+
+export module nihil.config:error;
+
+import nihil;
+
+namespace nihil::config {
+
+/*
+ * Exception thrown when an issue occurs with the configuration.
+ */
+export struct error : generic_error {
+	template<typename... Args>
+	error(std::format_string<Args...> fmt, Args &&...args)
+		: generic_error(fmt, std::forward<Args>(args)...)
+	{}
+};
+
+} // namespace nihil::config
diff --git a/nihil.config/nihil.config.ccm b/nihil.config/nihil.config.ccm
new file mode 100644
index 0000000..0b12885
--- /dev/null
+++ b/nihil.config/nihil.config.ccm
@@ -0,0 +1,12 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+export module nihil.config;
+
+export import :error;
+export import :option;
+export import :store;
+export import :string;
diff --git a/nihil.config/option.ccm b/nihil.config/option.ccm
new file mode 100644
index 0000000..207eb65
--- /dev/null
+++ b/nihil.config/option.ccm
@@ -0,0 +1,84 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+#include <string>
+
+#include <ucl++.h>
+
+export module nihil.config:option;
+
+import nihil;
+import :error;
+
+namespace nihil::config {
+
+/*
+ * Base class for options; this is what config_store interacts with.
+ */
+
+export struct option
+{
+	// Short name of this option.
+	auto name(this option const &self) noexcept -> std::string_view
+	{
+		return self._name;
+	}
+
+	// Human-readable description of this option.
+	auto description(this option const &self) noexcept -> std::string_view
+	{
+		return self._description;
+	}
+
+	// If true, this option is set to its default value.
+	auto is_default(this option const &self) noexcept -> bool
+	{
+		return self._is_default;
+	}
+
+	// Get or set this option as a string.
+	auto string(this option const &self) -> std::string
+	{
+		return self.get_string();
+	}
+
+	void string(this option &self, std::string_view value)
+	{
+		self.set_string(value);
+		self._is_default = false;
+	}
+
+	/*
+	 * Add this option to a UCL object.  This is used when writing the
+	 * configuration file.
+	 */
+	virtual void add_to_ucl(ucl_object_t *) const = 0;
+
+	// Not copyable or movable.
+	option(option const &) = delete;
+	auto operator=(option const &) -> option& = delete;
+
+protected:
+	option(std::string_view name,
+	       std::string_view description)
+		: _name(name)
+		, _description(description)
+	{
+	}
+
+	/*
+	 * Get or set this option as a string.
+	 */
+	virtual auto get_string() const -> std::string = 0;
+	virtual auto set_string(std::string_view) -> void = 0;
+
+private:
+	std::string _name;
+	std::string _description;
+	bool _is_default = true;
+};
+
+} // namespace nihil
diff --git a/nihil.config/store.ccm b/nihil.config/store.ccm
new file mode 100644
index 0000000..7ed4ccb
--- /dev/null
+++ b/nihil.config/store.ccm
@@ -0,0 +1,183 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+/*
+ * The configuration store.  There should only be one of these.
+ */
+
+#include <coroutine>
+#include <format>
+#include <map>
+
+export module nihil.config:store;
+
+import nihil;
+import :error;
+import :option;
+
+namespace nihil::config {
+
+// Exception thrown on an attempt to fetch an undefined option.
+export struct unknown_option final : error {
+	std::string varname;
+
+	unknown_option(std::string_view varname_)
+		: error("unknown configuration variable '{}'", varname_)
+		, varname(varname_)
+	{}
+};
+
+export struct store final {
+	/*
+	 * Get the global config store.
+	 */
+	static auto get() -> store& {
+		if (instance == nullptr)
+			instance = new store;
+
+		return *instance;
+	}
+
+	/*
+	 * Initialise the global config store.
+	 */
+#if 0
+	void init(context const &ctx) {
+		std::string config_text;
+
+		// Load the configuration text.
+		auto config_path = ctx.dbdir / "config.ucl";
+		try {
+			read_file(config_path, std::back_inserter(config_text));
+		} catch (io_error const &exc) {
+			// Ignore ENOENT, it simply means we haven't created the
+			// config file yet, so default values will be used.
+			if (exc.error == std::errc::no_such_file_or_directory)
+				return;
+			throw;
+		}
+
+		// Parse the UCL.
+
+		std::string err;
+		auto uclconfig = ucl::Ucl::parse(config_text, err);
+
+		if (!uclconfig)
+			throw error("{0}: {1}", config_path, err);
+
+		auto const &cfg = get();
+		for (auto const &uclvalue : uclconfig) {
+			auto &value = cfg.fetch(uclvalue.key());
+
+			switch (uclvalue.type()) {
+			case UCL_INT:
+				value.integer(uclvalue.int_value());
+				break;
+			case UCL_STRING:
+				value.string(uclvalue.string_value());
+				break;
+			default:
+				throw error(
+					"INTERNAL ERROR: unknown value type {0}",
+					static_cast<int>(uclvalue.type()));
+			}
+		}
+	}
+#endif
+
+	/*
+	 * Register a new value with the config store.
+	 */
+	auto register_option(this store &self, option *object) -> void
+	{
+		auto [it, okay] = self.options.insert(
+					std::pair{object->name(), object});
+
+		if (okay)
+			return;
+
+		throw error("INTERNAL ERROR: attempt to register "
+			    "duplicate config value '{0}'",
+			    object->name());
+	}
+
+	/*
+	 * Fetch an existing value in the config store.
+	 */
+	auto fetch(this store const &self, std::string_view name)
+		-> option &
+	{
+		if (auto it = self.options.find(name); it != self.options.end())
+			return *it->second;
+
+		throw unknown_option(name);
+	}
+
+	/*
+	 * Fetch all values in the configuration store.
+	 */
+	auto all(this auto &&self) -> nihil::generator<option const &>
+	{
+		for (auto &&it : self.options)
+			co_yield *it.second;
+	}
+
+	/*
+	 * Write all config values (except defaults) to disk.
+	 */
+#if 0
+	void store::write_all(this store const &self, context const &ctx) {
+		// The UCL C++ API doesn't seem to support creating new objects
+		// from scratch, so we use the C API here.  We should probably
+		// provider a better wrapper for this.
+
+		auto ucl = ::ucl_object_typed_new(UCL_OBJECT);
+		auto ucl_guard = guard([ucl] { ::ucl_object_unref(ucl); });
+
+		// Add all the options to the UCL object.
+		for (auto const &option : self.fetch_all()) {
+			if (option.is_default)
+				continue;
+
+			option.add_to_ucl(ucl);
+		}
+
+		// Dump the UCL object to a string.
+		auto *ucl_c_text = reinterpret_cast<char *>(
+					::ucl_object_emit(ucl, UCL_EMIT_CONFIG));
+		//NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
+		auto ucl_text_guard = guard([ucl_c_text] { ::free(ucl_c_text); });
+		std::string ucl_text(ucl_c_text);
+
+		// Write the object to a file.
+		auto config_path = ctx.dbdir / "config.ucl";
+
+		try {
+			safe_write_file(config_path, ucl_text);
+		} catch (io_error const &exc) {
+			throw error("{}", exc.what());
+		}
+	}
+#endif
+
+	// Not movable or copyable.
+	store(store const &) = delete;
+	store(store &&) = delete;
+	store& operator=(store const &) = delete;
+	store& operator=(store &&) = delete;
+
+private:
+	/*
+	 * The global configuration store, created by init() and accessed via
+	 * get().
+	 */
+	inline static store *instance = nullptr;
+
+	std::map<std::string_view, option *> options;
+	store() = default;
+};
+
+} // namespace nihil::config
diff --git a/nihil.config/string.ccm b/nihil.config/string.ccm
new file mode 100644
index 0000000..f3273c3
--- /dev/null
+++ b/nihil.config/string.ccm
@@ -0,0 +1,54 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+#include <stdexcept>
+#include <string>
+
+#include <ucl++.h>
+
+export module nihil.config:string;
+
+import nihil;
+import :option;
+import :store;
+
+namespace nihil::config {
+
+struct string final : option
+{
+	string(std::string &storage,
+	       std::string_view name,
+	       std::string_view description) noexcept
+		: option(name, description)
+		, _storage(storage)
+	{
+		store::get().register_option(this);
+	}
+
+	auto get_string() const -> std::string override
+	{
+		return _storage;
+	};
+
+	auto set_string(std::string_view new_value) -> void override
+	{
+		_storage = new_value;
+	}
+
+	auto add_to_ucl(ucl_object_t *ucl) const -> void override
+	{
+		auto ucl_value = ucl_object_fromstring_common(
+					_storage.data(), _storage.size(),
+					UCL_STRING_RAW);
+		ucl_object_insert_key(ucl, ucl_value,
+				      name().data(), name().size(), true);
+	}
+
+private:
+	std::string &_storage;
+};
+
+} // namespace nihil::config
diff --git a/nihil.ucl/CMakeLists.txt b/nihil.ucl/CMakeLists.txt
new file mode 100644
index 0000000..59021aa
--- /dev/null
+++ b/nihil.ucl/CMakeLists.txt
@@ -0,0 +1,13 @@
+# This source code is released into the public domain.
+
+pkg_check_modules(LIBUCL REQUIRED libucl)
+
+add_library(nihil.ucl STATIC)
+target_sources(nihil.ucl PUBLIC
+	FILE_SET modules TYPE CXX_MODULES FILES
+	nihil.ucl.ccm)
+target_compile_options(nihil.ucl PUBLIC ${LIBUCL_CFLAGS_OTHER})
+target_include_directories(nihil.ucl PUBLIC ${LIBUCL_INCLUDE_DIRS})
+target_link_libraries(nihil.ucl PUBLIC ${LIBUCL_LIBRARIES})
+target_link_directories(nihil.ucl PUBLIC ${LIBUCL_LIBRARY_DIRS})
+
diff --git a/nihil.ucl/nihil.ucl.ccm b/nihil.ucl/nihil.ucl.ccm
new file mode 100644
index 0000000..23151e0
--- /dev/null
+++ b/nihil.ucl/nihil.ucl.ccm
@@ -0,0 +1,9 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+export module nihil.ucl;
+
+// TODO: Implement.
diff --git a/nihil/CMakeLists.txt b/nihil/CMakeLists.txt
index 81f11c6..72f7e22 100644
--- a/nihil/CMakeLists.txt
+++ b/nihil/CMakeLists.txt
@@ -20,3 +20,8 @@ target_sources(nihil PUBLIC
 	spawn.ccm
 	tabulate.ccm
 	usage_error.ccm)
+
+if(NIHIL_TESTS)
+	add_subdirectory(tests)
+	enable_testing()
+endif()
diff --git a/nihil/tests/CMakeLists.txt b/nihil/tests/CMakeLists.txt
new file mode 100644
index 0000000..abeab88
--- /dev/null
+++ b/nihil/tests/CMakeLists.txt
@@ -0,0 +1,25 @@
+# This source code is released into the public domain.
+
+add_executable(nihil.test
+	command_map.cc
+	ctype.cc
+	fd.cc
+	generator.cc
+	generic_error.cc
+	getenv.cc
+	guard.cc
+	next_word.cc
+	skipws.cc
+	spawn.cc
+	tabulate.cc)
+
+target_link_libraries(nihil.test PRIVATE
+	nihil
+	Catch2::Catch2WithMain
+)
+
+find_package(Catch2 REQUIRED)
+
+include(CTest)
+include(Catch)
+catch_discover_tests(nihil.test)
diff --git a/nihil/tests/command_map.cc b/nihil/tests/command_map.cc
new file mode 100644
index 0000000..75b6f0d
--- /dev/null
+++ b/nihil/tests/command_map.cc
@@ -0,0 +1,41 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+namespace {
+
+auto cmd_sub1_called = false;
+auto cmd_sub1 = nihil::command<int>("cmd sub1", [](int, int, char **) -> int
+{
+	cmd_sub1_called = true;
+	return 0;
+});
+
+} // anonymous namespace
+
+TEST_CASE("command_map: basic", "[command_map]")
+{
+	auto args = std::vector<char const *>{
+		"cmd", "sub1", nullptr
+	};
+	auto argv = const_cast<char **>(args.data());
+	nihil::dispatch_command(0, args.size(), argv);
+	REQUIRE(cmd_sub1_called == true);
+}
+
+TEST_CASE("command_map: unknown command", "[command_map]")
+{
+	auto args = std::vector<char const *>{
+		"cmd", "nonesuch", nullptr
+	};
+	auto argv = const_cast<char **>(args.data());
+
+	REQUIRE_THROWS_AS(nihil::dispatch_command(0, args.size(), argv),
+			  nihil::usage_error);
+}
diff --git a/nihil/tests/ctype.cc b/nihil/tests/ctype.cc
new file mode 100644
index 0000000..87f5103
--- /dev/null
+++ b/nihil/tests/ctype.cc
@@ -0,0 +1,373 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("ctype: space", "[ctype]") {
+	auto is_utf8_space =
+		nihil::ctype_is(std::ctype_base::space,
+				std::locale("C.UTF-8"));
+
+	// '\v' (vertical tab) is a space
+	REQUIRE(nihil::is_space('\v') == true);
+	REQUIRE(nihil::is_space(L'\v') == true);
+
+	REQUIRE(nihil::is_c_space('\v') == true);
+	REQUIRE(nihil::is_c_space(L'\v') == true);
+
+	REQUIRE(is_utf8_space('\v') == true);
+	REQUIRE(is_utf8_space(L'\v') == true);
+
+	// 'x' is not a space
+	REQUIRE(nihil::is_space('x') == false);
+	REQUIRE(nihil::is_space(L'x') == false);
+
+	REQUIRE(nihil::is_c_space('x') == false);
+	REQUIRE(nihil::is_c_space(L'x') == false);
+
+	REQUIRE(is_utf8_space('x') == false);
+	REQUIRE(is_utf8_space(L'x') == false);
+
+	// U+2003 EM SPACE is a space
+	REQUIRE(nihil::is_space(L'\u2003') == false);
+	REQUIRE(nihil::is_c_space(L'\u2003') == false);
+	REQUIRE(is_utf8_space(L'\u2003') == true);
+}
+
+TEST_CASE("ctype: print", "[ctype]") {
+	auto is_utf8_print =
+		nihil::ctype_is(std::ctype_base::print,
+				std::locale("C.UTF-8"));
+
+	// 'x' is printable
+	REQUIRE(nihil::is_print('x') == true);
+	REQUIRE(nihil::is_print(L'x') == true);
+
+	REQUIRE(nihil::is_c_print('x') == true);
+	REQUIRE(nihil::is_c_print(L'x') == true);
+
+	REQUIRE(is_utf8_print('x') == true);
+	REQUIRE(is_utf8_print(L'x') == true);
+
+	// '\003' is not printable
+	REQUIRE(nihil::is_print('\003') == false);
+	REQUIRE(nihil::is_print(L'\003') == false);
+
+	REQUIRE(nihil::is_c_print('\003') == false);
+	REQUIRE(nihil::is_c_print(L'\003') == false);
+
+	REQUIRE(is_utf8_print('\003') == false);
+	REQUIRE(is_utf8_print(L'\003') == false);
+
+	// U+0410 CYRILLIC CAPITAL LETTER A is printable
+	REQUIRE(nihil::is_print(L'\u0410') == false);
+	REQUIRE(nihil::is_c_print(L'\u0410') == false);
+	REQUIRE(is_utf8_print(L'\u0410') == true);
+}
+
+TEST_CASE("ctype: cntrl", "[ctype]") {
+	auto is_utf8_cntrl =
+		nihil::ctype_is(std::ctype_base::cntrl,
+				std::locale("C.UTF-8"));
+
+	// '\003' is a control character
+	REQUIRE(nihil::is_cntrl('\003') == true);
+	REQUIRE(nihil::is_cntrl(L'\003') == true);
+
+	REQUIRE(nihil::is_c_cntrl('\003') == true);
+	REQUIRE(nihil::is_c_cntrl(L'\003') == true);
+
+	REQUIRE(is_utf8_cntrl('\003') == true);
+	REQUIRE(is_utf8_cntrl(L'\003') == true);
+
+
+	// 'x' is not a control character
+	REQUIRE(nihil::is_cntrl('x') == false);
+	REQUIRE(nihil::is_cntrl(L'x') == false);
+
+	REQUIRE(nihil::is_c_cntrl('x') == false);
+	REQUIRE(nihil::is_c_cntrl(L'x') == false);
+
+	REQUIRE(is_utf8_cntrl('x') == false);
+	REQUIRE(is_utf8_cntrl(L'x') == false);
+
+	// U+00AD SOFT HYPHEN is a control character.
+	REQUIRE(nihil::is_cntrl(L'\u00ad') == false);
+	REQUIRE(nihil::is_c_cntrl(L'\u00ad') == false);
+	REQUIRE(is_utf8_cntrl(L'\u00ad') == true);
+}
+
+TEST_CASE("ctype: upper", "[ctype]") {
+	auto is_utf8_upper =
+		nihil::ctype_is(std::ctype_base::upper,
+				std::locale("C.UTF-8"));
+
+	// 'A' is upper case
+	REQUIRE(nihil::is_upper('A') == true);
+	REQUIRE(nihil::is_upper(L'A') == true);
+
+	REQUIRE(nihil::is_c_upper('A') == true);
+	REQUIRE(nihil::is_c_upper(L'A') == true);
+
+	REQUIRE(is_utf8_upper('A') == true);
+	REQUIRE(is_utf8_upper(L'A') == true);
+
+	// 'a' is not upper case
+	REQUIRE(nihil::is_upper('a') == false);
+	REQUIRE(nihil::is_upper(L'a') == false);
+
+	REQUIRE(nihil::is_c_upper('a') == false);
+	REQUIRE(nihil::is_c_upper(L'a') == false);
+
+	REQUIRE(is_utf8_upper('a') == false);
+	REQUIRE(is_utf8_upper(L'a') == false);
+
+	// U+0410 CYRILLIC CAPITAL LETTER A is upper case
+	REQUIRE(nihil::is_upper(L'\u0410') == false);
+	REQUIRE(nihil::is_c_upper(L'\u0410') == false);
+	REQUIRE(is_utf8_upper(L'\u0410') == true);
+}
+
+TEST_CASE("ctype: lower", "[ctype]") {
+	auto is_utf8_lower =
+		nihil::ctype_is(std::ctype_base::lower,
+				std::locale("C.UTF-8"));
+
+	// 'a' is lower case
+	REQUIRE(nihil::is_lower('a') == true);
+	REQUIRE(nihil::is_lower(L'a') == true);
+
+	REQUIRE(nihil::is_c_lower('a') == true);
+	REQUIRE(nihil::is_c_lower(L'a') == true);
+
+	REQUIRE(is_utf8_lower('a') == true);
+	REQUIRE(is_utf8_lower(L'a') == true);
+
+	// 'A' is not lower case
+	REQUIRE(nihil::is_lower('A') == false);
+	REQUIRE(nihil::is_lower(L'A') == false);
+
+	REQUIRE(nihil::is_c_lower('A') == false);
+	REQUIRE(nihil::is_c_lower(L'A') == false);
+
+	REQUIRE(is_utf8_lower('A') == false);
+	REQUIRE(is_utf8_lower(L'A') == false);
+
+	// U+0430 CYRILLIC SMALL LETTER A
+	REQUIRE(nihil::is_lower(L'\u0430') == false);
+	REQUIRE(nihil::is_c_lower(L'\u0430') == false);
+	REQUIRE(is_utf8_lower(L'\u0430') == true);
+}
+
+TEST_CASE("ctype: alpha", "[ctype]") {
+	auto is_utf8_alpha =
+		nihil::ctype_is(std::ctype_base::alpha,
+				std::locale("C.UTF-8"));
+
+	// 'a' is alphabetical
+	REQUIRE(nihil::is_alpha('a') == true);
+	REQUIRE(nihil::is_alpha(L'a') == true);
+
+	REQUIRE(nihil::is_c_alpha('a') == true);
+	REQUIRE(nihil::is_c_alpha(L'a') == true);
+
+	REQUIRE(is_utf8_alpha('a') == true);
+	REQUIRE(is_utf8_alpha(L'a') == true);
+
+	// '1' is not alphabetical
+	REQUIRE(nihil::is_alpha('1') == false);
+	REQUIRE(nihil::is_alpha(L'1') == false);
+
+	REQUIRE(nihil::is_c_alpha('1') == false);
+	REQUIRE(nihil::is_c_alpha(L'1') == false);
+
+	REQUIRE(is_utf8_alpha('1') == false);
+	REQUIRE(is_utf8_alpha(L'1') == false);
+
+	// U+0430 CYRILLIC SMALL LETTER A
+	REQUIRE(nihil::is_alpha(L'\u0430') == false);
+	REQUIRE(nihil::is_c_alpha(L'\u0430') == false);
+	REQUIRE(is_utf8_alpha(L'\u0430') == true);
+}
+
+TEST_CASE("ctype: digit", "[ctype]") {
+	auto is_utf8_digit =
+		nihil::ctype_is(std::ctype_base::digit,
+				std::locale("C.UTF-8"));
+
+	// '1' is a digit
+	REQUIRE(nihil::is_digit('1') == true);
+	REQUIRE(nihil::is_digit(L'1') == true);
+
+	REQUIRE(nihil::is_c_digit('1') == true);
+	REQUIRE(nihil::is_c_digit(L'1') == true);
+
+	REQUIRE(is_utf8_digit('1') == true);
+	REQUIRE(is_utf8_digit(L'1') == true);
+
+	// 'a' is not a digit
+	REQUIRE(nihil::is_digit('a') == false);
+	REQUIRE(nihil::is_digit(L'a') == false);
+
+	REQUIRE(nihil::is_c_digit('a') == false);
+	REQUIRE(nihil::is_c_digit(L'a') == false);
+
+	REQUIRE(is_utf8_digit('a') == false);
+	REQUIRE(is_utf8_digit(L'a') == false);
+
+	// U+0660 ARABIC-INDIC DIGIT ZERO
+	REQUIRE(nihil::is_digit(L'\u0660') == false);
+	REQUIRE(nihil::is_c_digit(L'\u0660') == false);
+	REQUIRE(is_utf8_digit(L'\u0660') == true);
+}
+
+TEST_CASE("ctype: punct", "[ctype]") {
+	auto is_utf8_punct =
+		nihil::ctype_is(std::ctype_base::punct,
+				std::locale("C.UTF-8"));
+
+	// ';' is punctuation
+	REQUIRE(nihil::is_punct(';') == true);
+	REQUIRE(nihil::is_punct(L';') == true);
+
+	REQUIRE(nihil::is_c_punct(';') == true);
+	REQUIRE(nihil::is_c_punct(L';') == true);
+
+	REQUIRE(is_utf8_punct(';') == true);
+	REQUIRE(is_utf8_punct(L';') == true);
+
+	// 'a' is not punctuation
+	REQUIRE(nihil::is_punct('a') == false);
+	REQUIRE(nihil::is_punct(L'a') == false);
+
+	REQUIRE(nihil::is_c_punct('a') == false);
+	REQUIRE(nihil::is_c_punct(L'a') == false);
+
+	REQUIRE(is_utf8_punct('a') == false);
+	REQUIRE(is_utf8_punct(L'a') == false);
+
+	// U+00A1 INVERTED EXCLAMATION MARK
+	REQUIRE(nihil::is_punct(L'\u00A1') == false);
+	REQUIRE(nihil::is_c_punct(L'\u00A1') == false);
+	REQUIRE(is_utf8_punct(L'\u00A1') == true);
+}
+
+TEST_CASE("ctype: xdigit", "[ctype]") {
+	auto is_utf8_xdigit =
+		nihil::ctype_is(std::ctype_base::xdigit,
+				std::locale("C.UTF-8"));
+
+	// 'f' is an xdigit
+	REQUIRE(nihil::is_xdigit('f') == true);
+	REQUIRE(nihil::is_xdigit(L'f') == true);
+
+	REQUIRE(nihil::is_c_xdigit('f') == true);
+	REQUIRE(nihil::is_c_xdigit(L'f') == true);
+
+	REQUIRE(is_utf8_xdigit('f') == true);
+	REQUIRE(is_utf8_xdigit(L'f') == true);
+
+	// 'g' is not an xdigit
+	REQUIRE(nihil::is_xdigit('g') == false);
+	REQUIRE(nihil::is_xdigit(L'g') == false);
+
+	REQUIRE(nihil::is_c_xdigit('g') == false);
+	REQUIRE(nihil::is_c_xdigit(L'g') == false);
+
+	REQUIRE(is_utf8_xdigit('g') == false);
+	REQUIRE(is_utf8_xdigit(L'g') == false);
+}
+
+TEST_CASE("ctype: blank", "[ctype]") {
+	auto is_utf8_blank =
+		nihil::ctype_is(std::ctype_base::blank,
+				std::locale("C.UTF-8"));
+
+	// '\t' is a blank
+	REQUIRE(nihil::is_blank('\t') == true);
+	REQUIRE(nihil::is_blank(L'\t') == true);
+
+	REQUIRE(nihil::is_c_blank('\t') == true);
+	REQUIRE(nihil::is_c_blank(L'\t') == true);
+
+	REQUIRE(is_utf8_blank('\t') == true);
+	REQUIRE(is_utf8_blank(L'\t') == true);
+
+	// '\v' is not a blank
+	REQUIRE(nihil::is_blank('\v') == false);
+	REQUIRE(nihil::is_blank(L'\v') == false);
+
+	REQUIRE(nihil::is_c_blank('\v') == false);
+	REQUIRE(nihil::is_c_blank(L'\v') == false);
+
+	REQUIRE(is_utf8_blank('\v') == false);
+	REQUIRE(is_utf8_blank(L'\v') == false);
+
+	// There don't seem to be any UTF-8 blank characters, at least
+	// in FreeBSD libc.
+}
+
+TEST_CASE("ctype: alnum", "[ctype]") {
+	auto is_utf8_alnum =
+		nihil::ctype_is(std::ctype_base::alnum,
+				std::locale("C.UTF-8"));
+
+	// 'a' is alphanumeric
+	REQUIRE(nihil::is_alnum('a') == true);
+	REQUIRE(nihil::is_alnum(L'a') == true);
+
+	REQUIRE(nihil::is_c_alnum('a') == true);
+	REQUIRE(nihil::is_c_alnum(L'a') == true);
+
+	REQUIRE(is_utf8_alnum('a') == true);
+	REQUIRE(is_utf8_alnum(L'a') == true);
+
+	// '\t' is not a alnum
+	REQUIRE(nihil::is_alnum('\t') == false);
+	REQUIRE(nihil::is_alnum(L'\t') == false);
+
+	REQUIRE(nihil::is_c_alnum('\t') == false);
+	REQUIRE(nihil::is_c_alnum(L'\t') == false);
+
+	REQUIRE(is_utf8_alnum('\t') == false);
+	REQUIRE(is_utf8_alnum(L'\t') == false);
+
+	// U+0430 CYRILLIC SMALL LETTER A
+	REQUIRE(nihil::is_alnum(L'\u0430') == false);
+	REQUIRE(nihil::is_c_alnum(L'\u0430') == false);
+	REQUIRE(is_utf8_alnum(L'\u0430') == true);
+}
+
+TEST_CASE("ctype: graph", "[ctype]") {
+	auto is_utf8_graph =
+		nihil::ctype_is(std::ctype_base::graph,
+				std::locale("C.UTF-8"));
+
+	// 'a' is graphical 
+	REQUIRE(nihil::is_graph('a') == true);
+	REQUIRE(nihil::is_graph(L'a') == true);
+
+	REQUIRE(nihil::is_c_graph('a') == true);
+	REQUIRE(nihil::is_c_graph(L'a') == true);
+
+	REQUIRE(is_utf8_graph('a') == true);
+	REQUIRE(is_utf8_graph(L'a') == true);
+
+	// '\t' is not graphical
+	REQUIRE(nihil::is_graph('\t') == false);
+	REQUIRE(nihil::is_graph(L'\t') == false);
+
+	REQUIRE(nihil::is_c_graph('\t') == false);
+	REQUIRE(nihil::is_c_graph(L'\t') == false);
+
+	REQUIRE(is_utf8_graph('\t') == false);
+	REQUIRE(is_utf8_graph(L'\t') == false);
+
+	// U+0430 CYRILLIC SMALL LETTER A
+	REQUIRE(nihil::is_graph(L'\u0430') == false);
+	REQUIRE(nihil::is_c_graph(L'\u0430') == false);
+	REQUIRE(is_utf8_graph(L'\u0430') == true);
+}
diff --git a/nihil/tests/fd.cc b/nihil/tests/fd.cc
new file mode 100644
index 0000000..fbf353e
--- /dev/null
+++ b/nihil/tests/fd.cc
@@ -0,0 +1,200 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <span>
+
+#include <stdio.h>
+#include <fcntl.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+using namespace std::literals;
+
+namespace {
+
+// Test if an fd is open.
+auto fd_is_open(int fd) -> bool {
+	auto const ret = ::fcntl(fd, F_GETFL);
+	return ret == 0;
+}
+
+} // anonymous namespace
+
+TEST_CASE("fd: construct empty", "[fd]") {
+	nihil::fd fd;
+
+	REQUIRE(!fd);
+	REQUIRE_THROWS_AS(fd.get(), nihil::fd_logic_error);
+}
+
+TEST_CASE("fd: construct from fd", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	{
+		auto fd = nihil::fd(file);
+		REQUIRE(fd_is_open(fd.get()));
+	}
+
+	REQUIRE(!fd_is_open(file));
+}
+
+TEST_CASE("fd: close", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd = nihil::fd(file);
+	REQUIRE(fd);
+
+	auto const ret = fd.close();
+	REQUIRE(ret);
+	REQUIRE(!fd_is_open(file));
+}
+
+TEST_CASE("fd: move construct", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd1 = nihil::fd(file);
+	REQUIRE(fd_is_open(fd1.get()));
+
+	auto fd2(std::move(fd1));
+	REQUIRE(!fd1);
+	REQUIRE(fd2);
+	REQUIRE(fd2.get() == file);
+	REQUIRE(fd_is_open(file));
+}
+
+TEST_CASE("fd: move assign", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd1 = nihil::fd(file);
+	REQUIRE(fd_is_open(fd1.get()));
+
+	auto fd2 = nihil::fd();
+	REQUIRE(!fd2);
+
+	fd2 = std::move(fd1);
+
+	REQUIRE(!fd1);
+	REQUIRE(fd2);
+	REQUIRE(fd2.get() == file);
+	REQUIRE(fd_is_open(file));
+}
+
+TEST_CASE("fd: release", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd = nihil::fd(file);
+	auto fdesc = std::move(fd).release();
+	REQUIRE(!fd);
+	REQUIRE(fdesc == file);
+}
+
+TEST_CASE("fd: dup", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd = nihil::fd(file);
+	REQUIRE(fd);
+
+	auto fd2 = dup(fd);
+	REQUIRE(fd2);
+	REQUIRE(fd.get() != fd2->get());
+}
+
+TEST_CASE("fd: dup2", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	REQUIRE(!fd_is_open(666));
+
+	auto fd = nihil::fd(file);
+	auto fd2 = dup(fd, 666);
+
+	REQUIRE(fd);
+	REQUIRE(fd2);
+	REQUIRE(fd2->get() == 666);
+}
+
+TEST_CASE("fd: flags", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd = nihil::fd(file);
+
+	{
+		auto const ret = replaceflags(fd, 0);
+		REQUIRE(ret);
+		REQUIRE(getflags(fd) == 0);
+	}
+
+	{
+		auto const ret = setflags(fd, O_NONBLOCK);
+		REQUIRE(ret == O_NONBLOCK);
+		REQUIRE(getflags(fd) == O_NONBLOCK);
+	}
+
+	{
+		auto const ret = setflags(fd, O_SYNC);
+		REQUIRE(ret == (O_NONBLOCK|O_SYNC));
+		REQUIRE(getflags(fd) == (O_NONBLOCK|O_SYNC));
+	}
+
+	{
+		auto const ret = clearflags(fd, O_NONBLOCK);
+		REQUIRE(ret == O_SYNC);
+		REQUIRE(getflags(fd) == O_SYNC);
+	}
+}
+
+TEST_CASE("fd: fdflags", "[fd]") {
+	auto file = ::open("/dev/null", O_RDONLY);
+	REQUIRE(file > 0);
+
+	auto fd = nihil::fd(file);
+
+	{
+		auto const ret = replacefdflags(fd, 0);
+		REQUIRE(ret);
+		REQUIRE(getfdflags(fd) == 0);
+	}
+
+	{
+		auto const ret = setfdflags(fd, FD_CLOEXEC);
+		REQUIRE(ret == FD_CLOEXEC);
+		REQUIRE(getfdflags(fd) == FD_CLOEXEC);
+	}
+
+	{
+		auto const ret = clearfdflags(fd, FD_CLOEXEC);
+		REQUIRE(ret == 0);
+		REQUIRE(getfdflags(fd) == 0);
+	}
+}
+
+TEST_CASE("fd: pipe, read, write", "[fd]") {
+	auto fds = nihil::pipe();
+	REQUIRE(fds);
+
+	auto [fd1, fd2] = std::move(*fds);
+
+	auto constexpr test_string = "test string"sv;
+
+	auto ret = write(fd1, test_string);
+	REQUIRE(ret);
+	REQUIRE(*ret == test_string.size());
+
+	auto readbuf = std::array<char, test_string.size() * 2>{};
+	ret = read(fd2, readbuf);
+	REQUIRE(ret);
+	REQUIRE(*ret == test_string.size());
+
+	auto read_string = std::string_view(std::span(readbuf).subspan(0, *ret));
+	REQUIRE(read_string == test_string);
+}
diff --git a/nihil/tests/generator.cc b/nihil/tests/generator.cc
new file mode 100644
index 0000000..8657756
--- /dev/null
+++ b/nihil/tests/generator.cc
@@ -0,0 +1,56 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <coroutine>
+#include <ranges>
+#include <vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("generator: basic", "[generator]") 
+{
+	auto fn = [] () -> nihil::generator<int> {
+		co_yield 1;
+		co_yield 2;
+		co_yield 3;
+	};
+
+	auto values = std::vector<int>();
+	std::ranges::copy(fn(), std::back_inserter(values));
+
+	REQUIRE(values == std::vector{1, 2, 3});
+}
+
+TEST_CASE("generator: exceptions", "[generator]") 
+{
+	auto fn = [] () -> nihil::generator<int> {
+		co_yield 1;
+		throw std::runtime_error("test");
+	};
+
+	auto range = fn();
+	auto it = std::ranges::begin(range);
+	REQUIRE(*it == 1);
+	REQUIRE_THROWS_AS(it++, std::runtime_error);
+}
+
+TEST_CASE("generator: elements_of", "[generator]") 
+{
+	auto fn1 = [] -> nihil::generator<int> {
+		co_yield 1;
+		co_yield 2;
+		co_yield 3;
+	};
+
+	auto fn2 = [&fn1] -> nihil::generator<int> {
+		co_yield nihil::ranges::elements_of(fn1());
+	};
+
+	auto values = std::vector<int>();
+	std::ranges::copy(fn2(), std::back_inserter(values));
+
+	REQUIRE(values == std::vector{1, 2, 3});
+}
diff --git a/nihil/tests/generic_error.cc b/nihil/tests/generic_error.cc
new file mode 100644
index 0000000..b213af9
--- /dev/null
+++ b/nihil/tests/generic_error.cc
@@ -0,0 +1,17 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+using namespace std::literals;
+
+TEST_CASE("generic_error: basic", "[generic_error]") {
+	try {
+		throw nihil::generic_error("{} + {} = {}", 1, 2, 3);
+	} catch (nihil::generic_error const &exc) {
+		REQUIRE(exc.what() == "1 + 2 = 3"s);
+	}
+}
diff --git a/nihil/tests/getenv.cc b/nihil/tests/getenv.cc
new file mode 100644
index 0000000..adfa84f
--- /dev/null
+++ b/nihil/tests/getenv.cc
@@ -0,0 +1,48 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <ranges>
+#include <string>
+
+#include <unistd.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("getenv: existing value", "[getenv]")
+{
+	auto constexpr *name = "LFJAIL_TEST_VAR";
+	auto constexpr *value = "test is a test";
+
+	REQUIRE(::setenv(name, value, 1) == 0);
+
+	auto const s = nihil::getenv(name);
+	REQUIRE(s);
+	REQUIRE(*s == value);
+}
+
+TEST_CASE("getenv: non-existing value", "[getenv]")
+{
+	auto constexpr *name = "LFJAIL_TEST_VAR";
+
+	REQUIRE(::unsetenv(name) == 0);
+
+	auto const s = nihil::getenv(name);
+	REQUIRE(!s);
+	REQUIRE(s.error() == std::errc::no_such_file_or_directory);
+}
+
+// Force the call to getenv_r() to reallocate.
+TEST_CASE("getenv: long value")
+{
+	auto constexpr *name = "LFJAIL_TEST_VAR";
+	auto const value = std::string(4096, 'a');
+
+	REQUIRE(::setenv(name, value.c_str(), 1) == 0);
+
+	auto const s = nihil::getenv(name);
+	REQUIRE(s);
+	REQUIRE(*s == value);
+}
diff --git a/nihil/tests/guard.cc b/nihil/tests/guard.cc
new file mode 100644
index 0000000..f88aa9b
--- /dev/null
+++ b/nihil/tests/guard.cc
@@ -0,0 +1,20 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+using namespace std::literals;
+
+TEST_CASE("guard: basic", "[guard]") {
+	int n = 0;
+
+	{
+		auto guard = nihil::guard([&] { n = 1; });
+		REQUIRE(n == 0);
+	}
+
+	REQUIRE(n == 1);
+}
diff --git a/nihil/tests/next_word.cc b/nihil/tests/next_word.cc
new file mode 100644
index 0000000..4055485
--- /dev/null
+++ b/nihil/tests/next_word.cc
@@ -0,0 +1,65 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <locale>
+#include <string>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("next_word: basic", "[next_word]")
+{
+	using namespace std::literals;
+	auto s = "foo bar baz"sv;
+
+	auto words = nihil::next_word(s);
+	REQUIRE(words.first == "foo");
+	REQUIRE(words.second == " bar baz");
+
+	auto word = nihil::next_word(&s);
+	REQUIRE(word == "foo");
+	REQUIRE(s == " bar baz");
+}
+
+TEST_CASE("next_word: multiple spaces", "[next_word]")
+{
+	using namespace std::literals;
+	auto s = "foo  bar  baz"sv;
+
+	auto words = nihil::next_word(s);
+	REQUIRE(words.first == "foo");
+	REQUIRE(words.second == "  bar  baz");
+
+	auto word = nihil::next_word(&s);
+	REQUIRE(word == "foo");
+	REQUIRE(s == "  bar  baz");
+}
+
+TEST_CASE("next_word: leading spaces", "[next_word]")
+{
+	using namespace std::literals;
+	auto s = " \tfoo  bar  baz"sv;
+
+	auto words = nihil::next_word(s);
+	REQUIRE(words.first == "foo");
+	REQUIRE(words.second == "  bar  baz");
+
+	auto word = nihil::next_word(&s);
+	REQUIRE(word == "foo");
+	REQUIRE(s == "  bar  baz");
+}
+
+TEST_CASE("next_word: locale", "[next_word]")
+{
+	using namespace std::literals;
+	auto s = L"\u2003foo\u2003bar\u2003baz"sv;
+
+	auto words = nihil::next_word(s);
+	REQUIRE(words.first == s);
+
+	words = nihil::next_word(s, std::locale("C.UTF-8"));
+	REQUIRE(words.first == L"foo");
+	REQUIRE(words.second == L"\u2003bar\u2003baz");
+}
diff --git a/nihil/tests/skipws.cc b/nihil/tests/skipws.cc
new file mode 100644
index 0000000..2159e2e
--- /dev/null
+++ b/nihil/tests/skipws.cc
@@ -0,0 +1,45 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <locale>
+#include <string>
+using namespace std::literals;
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("skipws: basic", "[skipws]")
+{
+	REQUIRE(nihil::skipws("foo"sv) == "foo");
+	REQUIRE(nihil::skipws("   foo"sv) == "foo");
+	REQUIRE(nihil::skipws("foo "sv) == "foo ");
+	REQUIRE(nihil::skipws("foo bar"sv) == "foo bar");
+}
+
+TEST_CASE("skipws: pointer", "[skipws]")
+{
+	auto s = "foo"sv;
+	nihil::skipws(&s);
+	REQUIRE(s == "foo");
+
+	s = "   foo"sv;
+	nihil::skipws(&s);
+	REQUIRE(s == "foo");
+
+	s = "foo "sv;
+	nihil::skipws(&s);
+	REQUIRE(s == "foo ");
+
+	s = "foo bar"sv;
+	nihil::skipws(&s);
+	REQUIRE(s == "foo bar");
+}
+
+TEST_CASE("skipws: locale", "[skipws]")
+{
+	// Assume the default locale is C.
+	REQUIRE(nihil::skipws(L"\u2003foo"sv) == L"\u2003foo");
+	REQUIRE(nihil::skipws(L"\u2003foo"sv, std::locale("C.UTF-8")) == L"foo");
+}
diff --git a/nihil/tests/spawn.cc b/nihil/tests/spawn.cc
new file mode 100644
index 0000000..455223e
--- /dev/null
+++ b/nihil/tests/spawn.cc
@@ -0,0 +1,65 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+TEST_CASE("spawn: system", "[spawn]") {
+	using namespace nihil;
+	auto output = std::string();
+	auto result = spawn(shell("x=1; echo $x"),
+			    capture(stdout_fileno, output)).wait();
+
+	REQUIRE(result.okay());
+	REQUIRE(output == "1\n");
+}
+
+TEST_CASE("spawn: execv", "[spawn]") {
+	using namespace nihil;
+	auto output = std::string();
+	auto args = argv::from_args({"sh", "-c", "x=1; echo $x"});
+	auto result = spawn(execv("/bin/sh", std::move(args)),
+			    capture(stdout_fileno, output)).wait();
+
+	REQUIRE(result.okay());
+	REQUIRE(output == "1\n");
+}
+
+TEST_CASE("spawn: execvp", "[spawn]") {
+	using namespace nihil;
+	auto output = std::string();
+	auto args = argv::from_args({"sh", "-c", "x=1; echo $x"});
+	auto result = spawn(execvp("sh", std::move(args)),
+			    capture(stdout_fileno, output)).wait();
+
+	REQUIRE(result.okay());
+	REQUIRE(output == "1\n");
+}
+
+TEST_CASE("spawn: execl", "[spawn]") {
+	using namespace nihil;
+	auto output = std::string();
+	auto result = spawn(execl("/bin/sh", "sh", "-c", "x=1; echo $x"),
+			    capture(stdout_fileno, output)).wait();
+
+	REQUIRE(result.okay());
+	REQUIRE(output == "1\n");
+}
+
+TEST_CASE("spawn: execlp", "[spawn]") {
+	using namespace nihil;
+	auto output = std::string();
+	auto result = spawn(execlp("sh", "sh", "-c", "x=1; echo $x"),
+			    capture(stdout_fileno, output)).wait();
+
+	REQUIRE(result.okay());
+	REQUIRE(output == "1\n");
+}
+
+TEST_CASE("spawn: execlp failure", "[spawn]") {
+	using namespace nihil;
+	REQUIRE_THROWS_AS(execlp("lfjail_nonesuch_executable", "x"),
+			  executable_not_found);
+}
diff --git a/nihil/tests/tabulate.cc b/nihil/tests/tabulate.cc
new file mode 100644
index 0000000..84f8b33
--- /dev/null
+++ b/nihil/tests/tabulate.cc
@@ -0,0 +1,75 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+#include <iterator>
+#include <string>
+#include <vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+import nihil;
+
+using namespace std::literals;
+using namespace nihil;
+
+TEST_CASE("tabulate: basic", "[tabulate]")
+{
+	auto input = std::vector{
+		std::vector{"a",   "foo", "b"},
+		std::vector{"bar", "c",   "baz"},
+	};
+
+	auto result = std::string();
+	tabulate("{:1} {:2} {:3}", input, std::back_inserter(result));
+	REQUIRE(result ==
+"1   2   3\n"
+"a   foo b\n"
+"bar c   baz\n");
+}
+
+TEST_CASE("tabulate: basic wide", "[tabulate]")
+{
+	auto input = std::vector{
+		std::vector{L"a",   L"foo", L"b"},
+		std::vector{L"bar", L"c",   L"baz"},
+	};
+
+	auto result = std::wstring();
+	wtabulate(L"{:1} {:2} {:3}", input, std::back_inserter(result));
+
+	REQUIRE(result ==
+L"1   2   3\n"
+"a   foo b\n"
+"bar c   baz\n");
+}
+
+TEST_CASE("tabulate: jagged", "[tabulate]")
+{
+	auto input = std::vector{
+		std::vector{"a",   "foo", "b"},
+		std::vector{"bar", "baz"},
+	};
+
+	auto result = std::string();
+	tabulate("{:1} {:2} {:3}", input, std::back_inserter(result));
+	REQUIRE(result ==
+"1   2   3\n"
+"a   foo b\n"
+"bar baz\n");
+}
+
+TEST_CASE("tabulate: align", "[tabulate]")
+{
+	auto input = std::vector{
+		std::vector{"a", "longvalue", "s"},
+		std::vector{"a", "s",         "longvalue"},
+	};
+
+	auto result = std::string();
+	tabulate("{:1} {<:2} {>:3}", input, std::back_inserter(result));
+	REQUIRE(result ==
+"1 2                 3\n"
+"a longvalue         s\n"
+"a s         longvalue\n");
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
deleted file mode 100644
index abeab88..0000000
--- a/tests/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# This source code is released into the public domain.
-
-add_executable(nihil.test
-	command_map.cc
-	ctype.cc
-	fd.cc
-	generator.cc
-	generic_error.cc
-	getenv.cc
-	guard.cc
-	next_word.cc
-	skipws.cc
-	spawn.cc
-	tabulate.cc)
-
-target_link_libraries(nihil.test PRIVATE
-	nihil
-	Catch2::Catch2WithMain
-)
-
-find_package(Catch2 REQUIRED)
-
-include(CTest)
-include(Catch)
-catch_discover_tests(nihil.test)
diff --git a/tests/command_map.cc b/tests/command_map.cc
deleted file mode 100644
index 75b6f0d..0000000
--- a/tests/command_map.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <vector>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-namespace {
-
-auto cmd_sub1_called = false;
-auto cmd_sub1 = nihil::command<int>("cmd sub1", [](int, int, char **) -> int
-{
-	cmd_sub1_called = true;
-	return 0;
-});
-
-} // anonymous namespace
-
-TEST_CASE("command_map: basic", "[command_map]")
-{
-	auto args = std::vector<char const *>{
-		"cmd", "sub1", nullptr
-	};
-	auto argv = const_cast<char **>(args.data());
-	nihil::dispatch_command(0, args.size(), argv);
-	REQUIRE(cmd_sub1_called == true);
-}
-
-TEST_CASE("command_map: unknown command", "[command_map]")
-{
-	auto args = std::vector<char const *>{
-		"cmd", "nonesuch", nullptr
-	};
-	auto argv = const_cast<char **>(args.data());
-
-	REQUIRE_THROWS_AS(nihil::dispatch_command(0, args.size(), argv),
-			  nihil::usage_error);
-}
diff --git a/tests/ctype.cc b/tests/ctype.cc
deleted file mode 100644
index 87f5103..0000000
--- a/tests/ctype.cc
+++ /dev/null
@@ -1,373 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("ctype: space", "[ctype]") {
-	auto is_utf8_space =
-		nihil::ctype_is(std::ctype_base::space,
-				std::locale("C.UTF-8"));
-
-	// '\v' (vertical tab) is a space
-	REQUIRE(nihil::is_space('\v') == true);
-	REQUIRE(nihil::is_space(L'\v') == true);
-
-	REQUIRE(nihil::is_c_space('\v') == true);
-	REQUIRE(nihil::is_c_space(L'\v') == true);
-
-	REQUIRE(is_utf8_space('\v') == true);
-	REQUIRE(is_utf8_space(L'\v') == true);
-
-	// 'x' is not a space
-	REQUIRE(nihil::is_space('x') == false);
-	REQUIRE(nihil::is_space(L'x') == false);
-
-	REQUIRE(nihil::is_c_space('x') == false);
-	REQUIRE(nihil::is_c_space(L'x') == false);
-
-	REQUIRE(is_utf8_space('x') == false);
-	REQUIRE(is_utf8_space(L'x') == false);
-
-	// U+2003 EM SPACE is a space
-	REQUIRE(nihil::is_space(L'\u2003') == false);
-	REQUIRE(nihil::is_c_space(L'\u2003') == false);
-	REQUIRE(is_utf8_space(L'\u2003') == true);
-}
-
-TEST_CASE("ctype: print", "[ctype]") {
-	auto is_utf8_print =
-		nihil::ctype_is(std::ctype_base::print,
-				std::locale("C.UTF-8"));
-
-	// 'x' is printable
-	REQUIRE(nihil::is_print('x') == true);
-	REQUIRE(nihil::is_print(L'x') == true);
-
-	REQUIRE(nihil::is_c_print('x') == true);
-	REQUIRE(nihil::is_c_print(L'x') == true);
-
-	REQUIRE(is_utf8_print('x') == true);
-	REQUIRE(is_utf8_print(L'x') == true);
-
-	// '\003' is not printable
-	REQUIRE(nihil::is_print('\003') == false);
-	REQUIRE(nihil::is_print(L'\003') == false);
-
-	REQUIRE(nihil::is_c_print('\003') == false);
-	REQUIRE(nihil::is_c_print(L'\003') == false);
-
-	REQUIRE(is_utf8_print('\003') == false);
-	REQUIRE(is_utf8_print(L'\003') == false);
-
-	// U+0410 CYRILLIC CAPITAL LETTER A is printable
-	REQUIRE(nihil::is_print(L'\u0410') == false);
-	REQUIRE(nihil::is_c_print(L'\u0410') == false);
-	REQUIRE(is_utf8_print(L'\u0410') == true);
-}
-
-TEST_CASE("ctype: cntrl", "[ctype]") {
-	auto is_utf8_cntrl =
-		nihil::ctype_is(std::ctype_base::cntrl,
-				std::locale("C.UTF-8"));
-
-	// '\003' is a control character
-	REQUIRE(nihil::is_cntrl('\003') == true);
-	REQUIRE(nihil::is_cntrl(L'\003') == true);
-
-	REQUIRE(nihil::is_c_cntrl('\003') == true);
-	REQUIRE(nihil::is_c_cntrl(L'\003') == true);
-
-	REQUIRE(is_utf8_cntrl('\003') == true);
-	REQUIRE(is_utf8_cntrl(L'\003') == true);
-
-
-	// 'x' is not a control character
-	REQUIRE(nihil::is_cntrl('x') == false);
-	REQUIRE(nihil::is_cntrl(L'x') == false);
-
-	REQUIRE(nihil::is_c_cntrl('x') == false);
-	REQUIRE(nihil::is_c_cntrl(L'x') == false);
-
-	REQUIRE(is_utf8_cntrl('x') == false);
-	REQUIRE(is_utf8_cntrl(L'x') == false);
-
-	// U+00AD SOFT HYPHEN is a control character.
-	REQUIRE(nihil::is_cntrl(L'\u00ad') == false);
-	REQUIRE(nihil::is_c_cntrl(L'\u00ad') == false);
-	REQUIRE(is_utf8_cntrl(L'\u00ad') == true);
-}
-
-TEST_CASE("ctype: upper", "[ctype]") {
-	auto is_utf8_upper =
-		nihil::ctype_is(std::ctype_base::upper,
-				std::locale("C.UTF-8"));
-
-	// 'A' is upper case
-	REQUIRE(nihil::is_upper('A') == true);
-	REQUIRE(nihil::is_upper(L'A') == true);
-
-	REQUIRE(nihil::is_c_upper('A') == true);
-	REQUIRE(nihil::is_c_upper(L'A') == true);
-
-	REQUIRE(is_utf8_upper('A') == true);
-	REQUIRE(is_utf8_upper(L'A') == true);
-
-	// 'a' is not upper case
-	REQUIRE(nihil::is_upper('a') == false);
-	REQUIRE(nihil::is_upper(L'a') == false);
-
-	REQUIRE(nihil::is_c_upper('a') == false);
-	REQUIRE(nihil::is_c_upper(L'a') == false);
-
-	REQUIRE(is_utf8_upper('a') == false);
-	REQUIRE(is_utf8_upper(L'a') == false);
-
-	// U+0410 CYRILLIC CAPITAL LETTER A is upper case
-	REQUIRE(nihil::is_upper(L'\u0410') == false);
-	REQUIRE(nihil::is_c_upper(L'\u0410') == false);
-	REQUIRE(is_utf8_upper(L'\u0410') == true);
-}
-
-TEST_CASE("ctype: lower", "[ctype]") {
-	auto is_utf8_lower =
-		nihil::ctype_is(std::ctype_base::lower,
-				std::locale("C.UTF-8"));
-
-	// 'a' is lower case
-	REQUIRE(nihil::is_lower('a') == true);
-	REQUIRE(nihil::is_lower(L'a') == true);
-
-	REQUIRE(nihil::is_c_lower('a') == true);
-	REQUIRE(nihil::is_c_lower(L'a') == true);
-
-	REQUIRE(is_utf8_lower('a') == true);
-	REQUIRE(is_utf8_lower(L'a') == true);
-
-	// 'A' is not lower case
-	REQUIRE(nihil::is_lower('A') == false);
-	REQUIRE(nihil::is_lower(L'A') == false);
-
-	REQUIRE(nihil::is_c_lower('A') == false);
-	REQUIRE(nihil::is_c_lower(L'A') == false);
-
-	REQUIRE(is_utf8_lower('A') == false);
-	REQUIRE(is_utf8_lower(L'A') == false);
-
-	// U+0430 CYRILLIC SMALL LETTER A
-	REQUIRE(nihil::is_lower(L'\u0430') == false);
-	REQUIRE(nihil::is_c_lower(L'\u0430') == false);
-	REQUIRE(is_utf8_lower(L'\u0430') == true);
-}
-
-TEST_CASE("ctype: alpha", "[ctype]") {
-	auto is_utf8_alpha =
-		nihil::ctype_is(std::ctype_base::alpha,
-				std::locale("C.UTF-8"));
-
-	// 'a' is alphabetical
-	REQUIRE(nihil::is_alpha('a') == true);
-	REQUIRE(nihil::is_alpha(L'a') == true);
-
-	REQUIRE(nihil::is_c_alpha('a') == true);
-	REQUIRE(nihil::is_c_alpha(L'a') == true);
-
-	REQUIRE(is_utf8_alpha('a') == true);
-	REQUIRE(is_utf8_alpha(L'a') == true);
-
-	// '1' is not alphabetical
-	REQUIRE(nihil::is_alpha('1') == false);
-	REQUIRE(nihil::is_alpha(L'1') == false);
-
-	REQUIRE(nihil::is_c_alpha('1') == false);
-	REQUIRE(nihil::is_c_alpha(L'1') == false);
-
-	REQUIRE(is_utf8_alpha('1') == false);
-	REQUIRE(is_utf8_alpha(L'1') == false);
-
-	// U+0430 CYRILLIC SMALL LETTER A
-	REQUIRE(nihil::is_alpha(L'\u0430') == false);
-	REQUIRE(nihil::is_c_alpha(L'\u0430') == false);
-	REQUIRE(is_utf8_alpha(L'\u0430') == true);
-}
-
-TEST_CASE("ctype: digit", "[ctype]") {
-	auto is_utf8_digit =
-		nihil::ctype_is(std::ctype_base::digit,
-				std::locale("C.UTF-8"));
-
-	// '1' is a digit
-	REQUIRE(nihil::is_digit('1') == true);
-	REQUIRE(nihil::is_digit(L'1') == true);
-
-	REQUIRE(nihil::is_c_digit('1') == true);
-	REQUIRE(nihil::is_c_digit(L'1') == true);
-
-	REQUIRE(is_utf8_digit('1') == true);
-	REQUIRE(is_utf8_digit(L'1') == true);
-
-	// 'a' is not a digit
-	REQUIRE(nihil::is_digit('a') == false);
-	REQUIRE(nihil::is_digit(L'a') == false);
-
-	REQUIRE(nihil::is_c_digit('a') == false);
-	REQUIRE(nihil::is_c_digit(L'a') == false);
-
-	REQUIRE(is_utf8_digit('a') == false);
-	REQUIRE(is_utf8_digit(L'a') == false);
-
-	// U+0660 ARABIC-INDIC DIGIT ZERO
-	REQUIRE(nihil::is_digit(L'\u0660') == false);
-	REQUIRE(nihil::is_c_digit(L'\u0660') == false);
-	REQUIRE(is_utf8_digit(L'\u0660') == true);
-}
-
-TEST_CASE("ctype: punct", "[ctype]") {
-	auto is_utf8_punct =
-		nihil::ctype_is(std::ctype_base::punct,
-				std::locale("C.UTF-8"));
-
-	// ';' is punctuation
-	REQUIRE(nihil::is_punct(';') == true);
-	REQUIRE(nihil::is_punct(L';') == true);
-
-	REQUIRE(nihil::is_c_punct(';') == true);
-	REQUIRE(nihil::is_c_punct(L';') == true);
-
-	REQUIRE(is_utf8_punct(';') == true);
-	REQUIRE(is_utf8_punct(L';') == true);
-
-	// 'a' is not punctuation
-	REQUIRE(nihil::is_punct('a') == false);
-	REQUIRE(nihil::is_punct(L'a') == false);
-
-	REQUIRE(nihil::is_c_punct('a') == false);
-	REQUIRE(nihil::is_c_punct(L'a') == false);
-
-	REQUIRE(is_utf8_punct('a') == false);
-	REQUIRE(is_utf8_punct(L'a') == false);
-
-	// U+00A1 INVERTED EXCLAMATION MARK
-	REQUIRE(nihil::is_punct(L'\u00A1') == false);
-	REQUIRE(nihil::is_c_punct(L'\u00A1') == false);
-	REQUIRE(is_utf8_punct(L'\u00A1') == true);
-}
-
-TEST_CASE("ctype: xdigit", "[ctype]") {
-	auto is_utf8_xdigit =
-		nihil::ctype_is(std::ctype_base::xdigit,
-				std::locale("C.UTF-8"));
-
-	// 'f' is an xdigit
-	REQUIRE(nihil::is_xdigit('f') == true);
-	REQUIRE(nihil::is_xdigit(L'f') == true);
-
-	REQUIRE(nihil::is_c_xdigit('f') == true);
-	REQUIRE(nihil::is_c_xdigit(L'f') == true);
-
-	REQUIRE(is_utf8_xdigit('f') == true);
-	REQUIRE(is_utf8_xdigit(L'f') == true);
-
-	// 'g' is not an xdigit
-	REQUIRE(nihil::is_xdigit('g') == false);
-	REQUIRE(nihil::is_xdigit(L'g') == false);
-
-	REQUIRE(nihil::is_c_xdigit('g') == false);
-	REQUIRE(nihil::is_c_xdigit(L'g') == false);
-
-	REQUIRE(is_utf8_xdigit('g') == false);
-	REQUIRE(is_utf8_xdigit(L'g') == false);
-}
-
-TEST_CASE("ctype: blank", "[ctype]") {
-	auto is_utf8_blank =
-		nihil::ctype_is(std::ctype_base::blank,
-				std::locale("C.UTF-8"));
-
-	// '\t' is a blank
-	REQUIRE(nihil::is_blank('\t') == true);
-	REQUIRE(nihil::is_blank(L'\t') == true);
-
-	REQUIRE(nihil::is_c_blank('\t') == true);
-	REQUIRE(nihil::is_c_blank(L'\t') == true);
-
-	REQUIRE(is_utf8_blank('\t') == true);
-	REQUIRE(is_utf8_blank(L'\t') == true);
-
-	// '\v' is not a blank
-	REQUIRE(nihil::is_blank('\v') == false);
-	REQUIRE(nihil::is_blank(L'\v') == false);
-
-	REQUIRE(nihil::is_c_blank('\v') == false);
-	REQUIRE(nihil::is_c_blank(L'\v') == false);
-
-	REQUIRE(is_utf8_blank('\v') == false);
-	REQUIRE(is_utf8_blank(L'\v') == false);
-
-	// There don't seem to be any UTF-8 blank characters, at least
-	// in FreeBSD libc.
-}
-
-TEST_CASE("ctype: alnum", "[ctype]") {
-	auto is_utf8_alnum =
-		nihil::ctype_is(std::ctype_base::alnum,
-				std::locale("C.UTF-8"));
-
-	// 'a' is alphanumeric
-	REQUIRE(nihil::is_alnum('a') == true);
-	REQUIRE(nihil::is_alnum(L'a') == true);
-
-	REQUIRE(nihil::is_c_alnum('a') == true);
-	REQUIRE(nihil::is_c_alnum(L'a') == true);
-
-	REQUIRE(is_utf8_alnum('a') == true);
-	REQUIRE(is_utf8_alnum(L'a') == true);
-
-	// '\t' is not a alnum
-	REQUIRE(nihil::is_alnum('\t') == false);
-	REQUIRE(nihil::is_alnum(L'\t') == false);
-
-	REQUIRE(nihil::is_c_alnum('\t') == false);
-	REQUIRE(nihil::is_c_alnum(L'\t') == false);
-
-	REQUIRE(is_utf8_alnum('\t') == false);
-	REQUIRE(is_utf8_alnum(L'\t') == false);
-
-	// U+0430 CYRILLIC SMALL LETTER A
-	REQUIRE(nihil::is_alnum(L'\u0430') == false);
-	REQUIRE(nihil::is_c_alnum(L'\u0430') == false);
-	REQUIRE(is_utf8_alnum(L'\u0430') == true);
-}
-
-TEST_CASE("ctype: graph", "[ctype]") {
-	auto is_utf8_graph =
-		nihil::ctype_is(std::ctype_base::graph,
-				std::locale("C.UTF-8"));
-
-	// 'a' is graphical 
-	REQUIRE(nihil::is_graph('a') == true);
-	REQUIRE(nihil::is_graph(L'a') == true);
-
-	REQUIRE(nihil::is_c_graph('a') == true);
-	REQUIRE(nihil::is_c_graph(L'a') == true);
-
-	REQUIRE(is_utf8_graph('a') == true);
-	REQUIRE(is_utf8_graph(L'a') == true);
-
-	// '\t' is not graphical
-	REQUIRE(nihil::is_graph('\t') == false);
-	REQUIRE(nihil::is_graph(L'\t') == false);
-
-	REQUIRE(nihil::is_c_graph('\t') == false);
-	REQUIRE(nihil::is_c_graph(L'\t') == false);
-
-	REQUIRE(is_utf8_graph('\t') == false);
-	REQUIRE(is_utf8_graph(L'\t') == false);
-
-	// U+0430 CYRILLIC SMALL LETTER A
-	REQUIRE(nihil::is_graph(L'\u0430') == false);
-	REQUIRE(nihil::is_c_graph(L'\u0430') == false);
-	REQUIRE(is_utf8_graph(L'\u0430') == true);
-}
diff --git a/tests/fd.cc b/tests/fd.cc
deleted file mode 100644
index fbf353e..0000000
--- a/tests/fd.cc
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <span>
-
-#include <stdio.h>
-#include <fcntl.h>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-using namespace std::literals;
-
-namespace {
-
-// Test if an fd is open.
-auto fd_is_open(int fd) -> bool {
-	auto const ret = ::fcntl(fd, F_GETFL);
-	return ret == 0;
-}
-
-} // anonymous namespace
-
-TEST_CASE("fd: construct empty", "[fd]") {
-	nihil::fd fd;
-
-	REQUIRE(!fd);
-	REQUIRE_THROWS_AS(fd.get(), nihil::fd_logic_error);
-}
-
-TEST_CASE("fd: construct from fd", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	{
-		auto fd = nihil::fd(file);
-		REQUIRE(fd_is_open(fd.get()));
-	}
-
-	REQUIRE(!fd_is_open(file));
-}
-
-TEST_CASE("fd: close", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd = nihil::fd(file);
-	REQUIRE(fd);
-
-	auto const ret = fd.close();
-	REQUIRE(ret);
-	REQUIRE(!fd_is_open(file));
-}
-
-TEST_CASE("fd: move construct", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd1 = nihil::fd(file);
-	REQUIRE(fd_is_open(fd1.get()));
-
-	auto fd2(std::move(fd1));
-	REQUIRE(!fd1);
-	REQUIRE(fd2);
-	REQUIRE(fd2.get() == file);
-	REQUIRE(fd_is_open(file));
-}
-
-TEST_CASE("fd: move assign", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd1 = nihil::fd(file);
-	REQUIRE(fd_is_open(fd1.get()));
-
-	auto fd2 = nihil::fd();
-	REQUIRE(!fd2);
-
-	fd2 = std::move(fd1);
-
-	REQUIRE(!fd1);
-	REQUIRE(fd2);
-	REQUIRE(fd2.get() == file);
-	REQUIRE(fd_is_open(file));
-}
-
-TEST_CASE("fd: release", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd = nihil::fd(file);
-	auto fdesc = std::move(fd).release();
-	REQUIRE(!fd);
-	REQUIRE(fdesc == file);
-}
-
-TEST_CASE("fd: dup", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd = nihil::fd(file);
-	REQUIRE(fd);
-
-	auto fd2 = dup(fd);
-	REQUIRE(fd2);
-	REQUIRE(fd.get() != fd2->get());
-}
-
-TEST_CASE("fd: dup2", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	REQUIRE(!fd_is_open(666));
-
-	auto fd = nihil::fd(file);
-	auto fd2 = dup(fd, 666);
-
-	REQUIRE(fd);
-	REQUIRE(fd2);
-	REQUIRE(fd2->get() == 666);
-}
-
-TEST_CASE("fd: flags", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd = nihil::fd(file);
-
-	{
-		auto const ret = replaceflags(fd, 0);
-		REQUIRE(ret);
-		REQUIRE(getflags(fd) == 0);
-	}
-
-	{
-		auto const ret = setflags(fd, O_NONBLOCK);
-		REQUIRE(ret == O_NONBLOCK);
-		REQUIRE(getflags(fd) == O_NONBLOCK);
-	}
-
-	{
-		auto const ret = setflags(fd, O_SYNC);
-		REQUIRE(ret == (O_NONBLOCK|O_SYNC));
-		REQUIRE(getflags(fd) == (O_NONBLOCK|O_SYNC));
-	}
-
-	{
-		auto const ret = clearflags(fd, O_NONBLOCK);
-		REQUIRE(ret == O_SYNC);
-		REQUIRE(getflags(fd) == O_SYNC);
-	}
-}
-
-TEST_CASE("fd: fdflags", "[fd]") {
-	auto file = ::open("/dev/null", O_RDONLY);
-	REQUIRE(file > 0);
-
-	auto fd = nihil::fd(file);
-
-	{
-		auto const ret = replacefdflags(fd, 0);
-		REQUIRE(ret);
-		REQUIRE(getfdflags(fd) == 0);
-	}
-
-	{
-		auto const ret = setfdflags(fd, FD_CLOEXEC);
-		REQUIRE(ret == FD_CLOEXEC);
-		REQUIRE(getfdflags(fd) == FD_CLOEXEC);
-	}
-
-	{
-		auto const ret = clearfdflags(fd, FD_CLOEXEC);
-		REQUIRE(ret == 0);
-		REQUIRE(getfdflags(fd) == 0);
-	}
-}
-
-TEST_CASE("fd: pipe, read, write", "[fd]") {
-	auto fds = nihil::pipe();
-	REQUIRE(fds);
-
-	auto [fd1, fd2] = std::move(*fds);
-
-	auto constexpr test_string = "test string"sv;
-
-	auto ret = write(fd1, test_string);
-	REQUIRE(ret);
-	REQUIRE(*ret == test_string.size());
-
-	auto readbuf = std::array<char, test_string.size() * 2>{};
-	ret = read(fd2, readbuf);
-	REQUIRE(ret);
-	REQUIRE(*ret == test_string.size());
-
-	auto read_string = std::string_view(std::span(readbuf).subspan(0, *ret));
-	REQUIRE(read_string == test_string);
-}
diff --git a/tests/generator.cc b/tests/generator.cc
deleted file mode 100644
index 8657756..0000000
--- a/tests/generator.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <coroutine>
-#include <ranges>
-#include <vector>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("generator: basic", "[generator]") 
-{
-	auto fn = [] () -> nihil::generator<int> {
-		co_yield 1;
-		co_yield 2;
-		co_yield 3;
-	};
-
-	auto values = std::vector<int>();
-	std::ranges::copy(fn(), std::back_inserter(values));
-
-	REQUIRE(values == std::vector{1, 2, 3});
-}
-
-TEST_CASE("generator: exceptions", "[generator]") 
-{
-	auto fn = [] () -> nihil::generator<int> {
-		co_yield 1;
-		throw std::runtime_error("test");
-	};
-
-	auto range = fn();
-	auto it = std::ranges::begin(range);
-	REQUIRE(*it == 1);
-	REQUIRE_THROWS_AS(it++, std::runtime_error);
-}
-
-TEST_CASE("generator: elements_of", "[generator]") 
-{
-	auto fn1 = [] -> nihil::generator<int> {
-		co_yield 1;
-		co_yield 2;
-		co_yield 3;
-	};
-
-	auto fn2 = [&fn1] -> nihil::generator<int> {
-		co_yield nihil::ranges::elements_of(fn1());
-	};
-
-	auto values = std::vector<int>();
-	std::ranges::copy(fn2(), std::back_inserter(values));
-
-	REQUIRE(values == std::vector{1, 2, 3});
-}
diff --git a/tests/generic_error.cc b/tests/generic_error.cc
deleted file mode 100644
index b213af9..0000000
--- a/tests/generic_error.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-using namespace std::literals;
-
-TEST_CASE("generic_error: basic", "[generic_error]") {
-	try {
-		throw nihil::generic_error("{} + {} = {}", 1, 2, 3);
-	} catch (nihil::generic_error const &exc) {
-		REQUIRE(exc.what() == "1 + 2 = 3"s);
-	}
-}
diff --git a/tests/getenv.cc b/tests/getenv.cc
deleted file mode 100644
index adfa84f..0000000
--- a/tests/getenv.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <ranges>
-#include <string>
-
-#include <unistd.h>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("getenv: existing value", "[getenv]")
-{
-	auto constexpr *name = "LFJAIL_TEST_VAR";
-	auto constexpr *value = "test is a test";
-
-	REQUIRE(::setenv(name, value, 1) == 0);
-
-	auto const s = nihil::getenv(name);
-	REQUIRE(s);
-	REQUIRE(*s == value);
-}
-
-TEST_CASE("getenv: non-existing value", "[getenv]")
-{
-	auto constexpr *name = "LFJAIL_TEST_VAR";
-
-	REQUIRE(::unsetenv(name) == 0);
-
-	auto const s = nihil::getenv(name);
-	REQUIRE(!s);
-	REQUIRE(s.error() == std::errc::no_such_file_or_directory);
-}
-
-// Force the call to getenv_r() to reallocate.
-TEST_CASE("getenv: long value")
-{
-	auto constexpr *name = "LFJAIL_TEST_VAR";
-	auto const value = std::string(4096, 'a');
-
-	REQUIRE(::setenv(name, value.c_str(), 1) == 0);
-
-	auto const s = nihil::getenv(name);
-	REQUIRE(s);
-	REQUIRE(*s == value);
-}
diff --git a/tests/guard.cc b/tests/guard.cc
deleted file mode 100644
index f88aa9b..0000000
--- a/tests/guard.cc
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-using namespace std::literals;
-
-TEST_CASE("guard: basic", "[guard]") {
-	int n = 0;
-
-	{
-		auto guard = nihil::guard([&] { n = 1; });
-		REQUIRE(n == 0);
-	}
-
-	REQUIRE(n == 1);
-}
diff --git a/tests/next_word.cc b/tests/next_word.cc
deleted file mode 100644
index 4055485..0000000
--- a/tests/next_word.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <locale>
-#include <string>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("next_word: basic", "[next_word]")
-{
-	using namespace std::literals;
-	auto s = "foo bar baz"sv;
-
-	auto words = nihil::next_word(s);
-	REQUIRE(words.first == "foo");
-	REQUIRE(words.second == " bar baz");
-
-	auto word = nihil::next_word(&s);
-	REQUIRE(word == "foo");
-	REQUIRE(s == " bar baz");
-}
-
-TEST_CASE("next_word: multiple spaces", "[next_word]")
-{
-	using namespace std::literals;
-	auto s = "foo  bar  baz"sv;
-
-	auto words = nihil::next_word(s);
-	REQUIRE(words.first == "foo");
-	REQUIRE(words.second == "  bar  baz");
-
-	auto word = nihil::next_word(&s);
-	REQUIRE(word == "foo");
-	REQUIRE(s == "  bar  baz");
-}
-
-TEST_CASE("next_word: leading spaces", "[next_word]")
-{
-	using namespace std::literals;
-	auto s = " \tfoo  bar  baz"sv;
-
-	auto words = nihil::next_word(s);
-	REQUIRE(words.first == "foo");
-	REQUIRE(words.second == "  bar  baz");
-
-	auto word = nihil::next_word(&s);
-	REQUIRE(word == "foo");
-	REQUIRE(s == "  bar  baz");
-}
-
-TEST_CASE("next_word: locale", "[next_word]")
-{
-	using namespace std::literals;
-	auto s = L"\u2003foo\u2003bar\u2003baz"sv;
-
-	auto words = nihil::next_word(s);
-	REQUIRE(words.first == s);
-
-	words = nihil::next_word(s, std::locale("C.UTF-8"));
-	REQUIRE(words.first == L"foo");
-	REQUIRE(words.second == L"\u2003bar\u2003baz");
-}
diff --git a/tests/skipws.cc b/tests/skipws.cc
deleted file mode 100644
index 2159e2e..0000000
--- a/tests/skipws.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <locale>
-#include <string>
-using namespace std::literals;
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("skipws: basic", "[skipws]")
-{
-	REQUIRE(nihil::skipws("foo"sv) == "foo");
-	REQUIRE(nihil::skipws("   foo"sv) == "foo");
-	REQUIRE(nihil::skipws("foo "sv) == "foo ");
-	REQUIRE(nihil::skipws("foo bar"sv) == "foo bar");
-}
-
-TEST_CASE("skipws: pointer", "[skipws]")
-{
-	auto s = "foo"sv;
-	nihil::skipws(&s);
-	REQUIRE(s == "foo");
-
-	s = "   foo"sv;
-	nihil::skipws(&s);
-	REQUIRE(s == "foo");
-
-	s = "foo "sv;
-	nihil::skipws(&s);
-	REQUIRE(s == "foo ");
-
-	s = "foo bar"sv;
-	nihil::skipws(&s);
-	REQUIRE(s == "foo bar");
-}
-
-TEST_CASE("skipws: locale", "[skipws]")
-{
-	// Assume the default locale is C.
-	REQUIRE(nihil::skipws(L"\u2003foo"sv) == L"\u2003foo");
-	REQUIRE(nihil::skipws(L"\u2003foo"sv, std::locale("C.UTF-8")) == L"foo");
-}
diff --git a/tests/spawn.cc b/tests/spawn.cc
deleted file mode 100644
index 455223e..0000000
--- a/tests/spawn.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-TEST_CASE("spawn: system", "[spawn]") {
-	using namespace nihil;
-	auto output = std::string();
-	auto result = spawn(shell("x=1; echo $x"),
-			    capture(stdout_fileno, output)).wait();
-
-	REQUIRE(result.okay());
-	REQUIRE(output == "1\n");
-}
-
-TEST_CASE("spawn: execv", "[spawn]") {
-	using namespace nihil;
-	auto output = std::string();
-	auto args = argv::from_args({"sh", "-c", "x=1; echo $x"});
-	auto result = spawn(execv("/bin/sh", std::move(args)),
-			    capture(stdout_fileno, output)).wait();
-
-	REQUIRE(result.okay());
-	REQUIRE(output == "1\n");
-}
-
-TEST_CASE("spawn: execvp", "[spawn]") {
-	using namespace nihil;
-	auto output = std::string();
-	auto args = argv::from_args({"sh", "-c", "x=1; echo $x"});
-	auto result = spawn(execvp("sh", std::move(args)),
-			    capture(stdout_fileno, output)).wait();
-
-	REQUIRE(result.okay());
-	REQUIRE(output == "1\n");
-}
-
-TEST_CASE("spawn: execl", "[spawn]") {
-	using namespace nihil;
-	auto output = std::string();
-	auto result = spawn(execl("/bin/sh", "sh", "-c", "x=1; echo $x"),
-			    capture(stdout_fileno, output)).wait();
-
-	REQUIRE(result.okay());
-	REQUIRE(output == "1\n");
-}
-
-TEST_CASE("spawn: execlp", "[spawn]") {
-	using namespace nihil;
-	auto output = std::string();
-	auto result = spawn(execlp("sh", "sh", "-c", "x=1; echo $x"),
-			    capture(stdout_fileno, output)).wait();
-
-	REQUIRE(result.okay());
-	REQUIRE(output == "1\n");
-}
-
-TEST_CASE("spawn: execlp failure", "[spawn]") {
-	using namespace nihil;
-	REQUIRE_THROWS_AS(execlp("lfjail_nonesuch_executable", "x"),
-			  executable_not_found);
-}
diff --git a/tests/tabulate.cc b/tests/tabulate.cc
deleted file mode 100644
index 84f8b33..0000000
--- a/tests/tabulate.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * This source code is released into the public domain.
- */
-
-#include <iterator>
-#include <string>
-#include <vector>
-
-#include <catch2/catch_test_macros.hpp>
-
-import nihil;
-
-using namespace std::literals;
-using namespace nihil;
-
-TEST_CASE("tabulate: basic", "[tabulate]")
-{
-	auto input = std::vector{
-		std::vector{"a",   "foo", "b"},
-		std::vector{"bar", "c",   "baz"},
-	};
-
-	auto result = std::string();
-	tabulate("{:1} {:2} {:3}", input, std::back_inserter(result));
-	REQUIRE(result ==
-"1   2   3\n"
-"a   foo b\n"
-"bar c   baz\n");
-}
-
-TEST_CASE("tabulate: basic wide", "[tabulate]")
-{
-	auto input = std::vector{
-		std::vector{L"a",   L"foo", L"b"},
-		std::vector{L"bar", L"c",   L"baz"},
-	};
-
-	auto result = std::wstring();
-	wtabulate(L"{:1} {:2} {:3}", input, std::back_inserter(result));
-
-	REQUIRE(result ==
-L"1   2   3\n"
-"a   foo b\n"
-"bar c   baz\n");
-}
-
-TEST_CASE("tabulate: jagged", "[tabulate]")
-{
-	auto input = std::vector{
-		std::vector{"a",   "foo", "b"},
-		std::vector{"bar", "baz"},
-	};
-
-	auto result = std::string();
-	tabulate("{:1} {:2} {:3}", input, std::back_inserter(result));
-	REQUIRE(result ==
-"1   2   3\n"
-"a   foo b\n"
-"bar baz\n");
-}
-
-TEST_CASE("tabulate: align", "[tabulate]")
-{
-	auto input = std::vector{
-		std::vector{"a", "longvalue", "s"},
-		std::vector{"a", "s",         "longvalue"},
-	};
-
-	auto result = std::string();
-	tabulate("{:1} {<:2} {>:3}", input, std::back_inserter(result));
-	REQUIRE(result ==
-"1 2                 3\n"
-"a longvalue         s\n"
-"a s         longvalue\n");
-}
-- 
cgit v1.2.3