Update to open3d conversion logic

Merge remote-tracking branch 'origin/fmt_formatter_for_math'

openVulkanoCpp/Extensions/FmtFormatter.hpp

@@ -13,9 +13,17 @@
 #else
 #error "Failed to find fmt include"
 #endif
-#include "Math/ByteSize.hpp"
 #include "Math/Math.hpp"
+#include "Math/ByteSize.hpp"
+#include "Math/DenseVector3i.hpp"
+#include "Math/Float16.hpp"
+#include "Math/Int24.hpp"
 #include "Math/Range.hpp"
+#include "Math/RGB10A2.hpp"
+#include "Math/RGB565.hpp"
+#include "Math/RGBA5551.hpp"
+#include "Math/Timestamp.hpp"
+#include "Math/UInt24.hpp"
 #include "Base/UUID.hpp"
 #include <filesystem>
 #include <fmt/chrono.h>
@@ -49,132 +57,170 @@ template<> struct fmt::formatter<std::filesystem::path> : fmt::formatter<std::st
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::vec<2, T, Q>>
+struct fmt::formatter<glm::vec<2, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::vec<2, T, Q>& v, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "(");
-
+        formatter<T>::format(v.x, ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::vec<2, T, Q>& v, FormatContext& ctx) const
+        formatter<T>::format(v.y, ctx);
-	{
+        return fmt::format_to(ctx.out(), ")");
-		return fmt::format_to(ctx.out(), "({}, {})", v.x, v.y);
+    }
-	}
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::vec<3, T, Q>>
+struct fmt::formatter<glm::vec<3, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::vec<3, T, Q>& v, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "(");
-
+        formatter<T>::format(v.x, ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::vec<3, T, Q>& v, FormatContext& ctx) const
+        formatter<T>::format(v.y, ctx);
-	{
+        fmt::format_to(ctx.out(), ", ");
-		return fmt::format_to(ctx.out(), "({}, {}, {})", v.x, v.y, v.z);
+        formatter<T>::format(v.z, ctx);
-	}
+        return fmt::format_to(ctx.out(), ")");
+    }
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::vec<4, T, Q>>
+struct fmt::formatter<glm::vec<4, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::vec<4, T, Q>& v, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "(");
-
+        formatter<T>::format(v.x, ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::vec<4, T, Q>& v, FormatContext& ctx) const
+        formatter<T>::format(v.y, ctx);
-	{
+        fmt::format_to(ctx.out(), ", ");
-		return fmt::format_to(ctx.out(), "({}, {}, {}, {})", v.x, v.y, v.z, v.w);
+        formatter<T>::format(v.z, ctx);
-	}
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(v.w, ctx);
+        return fmt::format_to(ctx.out(), ")");
+    }
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::mat<2, 2, T, Q>>
+struct fmt::formatter<glm::mat<2, 2, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::mat<2, 2, T, Q>& m, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "[[");
-
+        formatter<T>::format(m[0][0], ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::mat<2, 2, T, Q>& m, FormatContext& ctx) const
+        formatter<T>::format(m[1][0], ctx);
-	{
+        fmt::format_to(ctx.out(), "], [");
-		return fmt::format_to(ctx.out(), "[[{}, {}], [{}, {}]]",
+        formatter<T>::format(m[0][1], ctx);
-			m[0][0], m[1][0],
+        fmt::format_to(ctx.out(), ", ");
-			m[0][1], m[1][1]);
+        formatter<T>::format(m[1][1], ctx);
-	}
+        return fmt::format_to(ctx.out(), "]]");
+    }
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::mat<3, 3, T, Q>>
+struct fmt::formatter<glm::mat<3, 3, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::mat<3, 3, T, Q>& m, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "[[");
-
+        formatter<T>::format(m[0][0], ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::mat<3, 3, T, Q>& m, FormatContext& ctx) const
+        formatter<T>::format(m[1][0], ctx);
-	{
+        fmt::format_to(ctx.out(), ", ");
-		return fmt::format_to(ctx.out(), "[[{}, {}, {}], [{}, {}, {}], [{}, {}, {}]]",
+        formatter<T>::format(m[2][0], ctx);
-			m[0][0], m[1][0], m[2][0],
+        fmt::format_to(ctx.out(), "], [");
-			m[0][1], m[1][1], m[2][1],
+        formatter<T>::format(m[0][1], ctx);
-			m[0][2], m[1][2], m[2][2]);
+        fmt::format_to(ctx.out(), ", ");
-	}
+        formatter<T>::format(m[1][1], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[2][1], ctx);
+        fmt::format_to(ctx.out(), "], [");
+        formatter<T>::format(m[0][2], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[1][2], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[2][2], ctx);
+        return fmt::format_to(ctx.out(), "]]");
+    }
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::mat<4, 4, T, Q>>
+struct fmt::formatter<glm::mat<4, 4, T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::mat<4, 4, T, Q>& m, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "[[");
-
+        formatter<T>::format(m[0][0], ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::mat<4, 4, T, Q>& m, FormatContext& ctx) const
+        formatter<T>::format(m[1][0], ctx);
-	{
+        fmt::format_to(ctx.out(), ", ");
-		return fmt::format_to(ctx.out(), "[[{}, {}, {}, {}], [{}, {}, {}, {}], [{}, {}, {}, {}], [{}, {}, {}, {}]]",
+        formatter<T>::format(m[2][0], ctx);
-			m[0][0], m[1][0], m[2][0], m[3][0],
+        fmt::format_to(ctx.out(), ", ");
-			m[0][1], m[1][1], m[2][1], m[3][1],
+        formatter<T>::format(m[3][0], ctx);
-			m[0][2], m[1][2], m[2][2], m[3][2],
+        fmt::format_to(ctx.out(), "], [");
-			m[0][3], m[1][3], m[2][3], m[3][3]);
+        formatter<T>::format(m[0][1], ctx);
-	}
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[1][1], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[2][1], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[3][1], ctx);
+        fmt::format_to(ctx.out(), "], [");
+        formatter<T>::format(m[0][2], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[1][2], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[2][2], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[3][2], ctx);
+        fmt::format_to(ctx.out(), "], [");
+        formatter<T>::format(m[0][3], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[1][3], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[2][3], ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(m[3][3], ctx);
+        return fmt::format_to(ctx.out(), "]]");
+    }
 };
 
 template<typename T, glm::qualifier Q>
-struct fmt::formatter<glm::qua<T, Q>>
+struct fmt::formatter<glm::qua<T, Q>> : fmt::formatter<T>
 {
-	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
+    template<typename FormatContext>
-	{
+    auto format(const glm::qua<T, Q>& q, FormatContext& ctx) const
-		return ctx.begin();
+    {
-	}
+        fmt::format_to(ctx.out(), "(");
-
+        formatter<T>::format(q.w, ctx);
-	template<typename FormatContext>
+        fmt::format_to(ctx.out(), ", ");
-	auto format(const glm::qua<T, Q>& q, FormatContext& ctx) const
+        formatter<T>::format(q.x, ctx);
-	{
+        fmt::format_to(ctx.out(), ", ");
-		return fmt::format_to(ctx.out(), "({}, {}, {}, {})", q.w, q.x, q.y, q.z);
+        formatter<T>::format(q.y, ctx);
-	}
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(q.z, ctx);
+        return fmt::format_to(ctx.out(), ")");
+    }
 };
 
 template<typename T>
-struct fmt::formatter<OpenVulkano::Math::Range<T>> : fmt::formatter<std::string>
+struct fmt::formatter<OpenVulkano::Math::Range<T>> : fmt::formatter<T>
 {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
     template<typename FormatContext>
     auto format(const OpenVulkano::Math::Range<T>& range, FormatContext& ctx) const
     {
-        return fmt::format_to(ctx.out(), "[{}, {}]", range.min, range.max);
+        fmt::format_to(ctx.out(), "[");
+        formatter<T>::format(range.min, ctx);
+        fmt::format_to(ctx.out(), ", ");
+        formatter<T>::format(range.max, ctx);
+        return fmt::format_to(ctx.out(), "]");
     }
 };
 
@@ -193,3 +239,117 @@ struct fmt::formatter<OpenVulkano::UUID> : fmt::formatter<std::string>
         return fmt::format_to(ctx.out(), "{}", uuid.string());
     }
 };
+
+template<>
+struct fmt::formatter<OpenVulkano::Math::RGB565>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const OpenVulkano::Math::RGB565& color, FormatContext& ctx) const
+    {
+        return fmt::format_to(ctx.out(), "RGB565(r:{}, g:{}, b:{})", 
+            color.r, color.g, color.b);
+    }
+};
+
+template<>
+struct fmt::formatter<OpenVulkano::Math::RGBA5551>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const OpenVulkano::Math::RGBA5551& color, FormatContext& ctx) const
+    {
+        return fmt::format_to(ctx.out(), "RGBA5551(r:{}, g:{}, b:{}, a:{})", 
+            color.r, color.g, color.b, color.a);
+    }
+};
+
+template<typename TYPE>
+struct fmt::formatter<OpenVulkano::Math::RGB10A2<TYPE>>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const OpenVulkano::Math::RGB10A2<TYPE>& color, FormatContext& ctx) const
+    {
+        return fmt::format_to(ctx.out(), "RGB10A2(r:{}, g:{}, b:{}, a:{})", 
+            color.r, color.g, color.b, color.a);
+    }
+};
+
+template<typename T, bool REDUCE_Y_RESOLUTION, bool ASSERT_INPUT_VALUES, int BITS_PER_COMPONENT>
+struct fmt::formatter<OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>& vec, 
+                FormatContext& ctx) const
+    {
+		return fmt::format_to(ctx.out(), "DenseVector3i({}, {}, {})", vec.X(), vec.Y(), vec.Z());
+	}
+};
+
+template<>
+struct fmt::formatter<OpenVulkano::Math::Timestamp>
+{
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const OpenVulkano::Math::Timestamp& ts, FormatContext& ctx) const
+    {
+        return fmt::format_to(ctx.out(), "{}ns", ts.GetNanos());
+    }
+};
+
+template<>
+struct fmt::formatter<float16> : fmt::formatter<float>
+{
+    template<typename FormatContext>
+    auto format(const float16& f, FormatContext& ctx) const
+    {
+        return fmt::formatter<float>::format(static_cast<float>(f), ctx);
+    }
+};
+
+template<>
+struct fmt::formatter<OpenVulkano::int24> : fmt::formatter<int32_t>
+{
+    template<typename FormatContext>
+    auto format(const OpenVulkano::int24& i, FormatContext& ctx) const
+    {
+        return fmt::formatter<int32_t>::format(static_cast<int32_t>(i), ctx);
+    }
+};
+
+template<>
+struct fmt::formatter<OpenVulkano::uint24> : fmt::formatter<int32_t>
+{
+    template<typename FormatContext>
+    auto format(const OpenVulkano::uint24& i, FormatContext& ctx) const
+    {
+        return fmt::formatter<int32_t>::format(static_cast<int>(i), ctx);
+    }
+};

openVulkanoCpp/Math/ByteSize.hpp

@@ -72,7 +72,7 @@ namespace OpenVulkano
 		{
 			for (int i = (si ? EB : EiB); i >= (si ? kB : kiB); i--)
 			{
-				if (size > FACTORS[i]) return { static_cast<Unit>(i) };
+				if (size >= FACTORS[i]) return { static_cast<Unit>(i) };
 			}
 			return { B };
 		}
@@ -162,4 +162,3 @@ namespace OpenVulkano
 	constexpr ByteSize operator""  _PB(unsigned long long int num) { return { num, ByteSizeUnit::PB }; }
 	constexpr ByteSize operator""  _EB(unsigned long long int num) { return { num, ByteSizeUnit::EB }; }
 }
-

openVulkanoCpp/Math/Float16.hpp

@@ -18,6 +18,7 @@
 #elif __has_keyword(__fp16)
 	typedef __fp16      float16;
 #else
+#define USING_CUSTOM_FLOAT16
 
 class float16
 {

openVulkanoCpp/Vulkan/Resources/MemoryPool.cpp

@@ -151,7 +151,7 @@ namespace OpenVulkano::Vulkan
 				}
 			}
 		}
-		return CreateBuffer(size, vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eHostCoherent/* | vk::MemoryPropertyFlagBits::eDeviceLocal*/);
+		return CreateBuffer(size, vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eHostCoherent | vk::MemoryPropertyFlagBits::eHostCached /*| vk::MemoryPropertyFlagBits::eDeviceLocal*/);
 	}
 
 	void ManagedBufferDeleter::operator()(ManagedBuffer* buffer)

tests/Extensions/FmtFormatterTest.cpp

@@ -0,0 +1,179 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <catch2/catch_all.hpp>
+#include <fmt/format.h>
+
+#include "Extensions/FmtFormatter.hpp"
+
+using namespace OpenVulkano;
+using namespace OpenVulkano::Math;
+
+TEST_CASE("GLM Vector Formatters", "[fmt]")
+{
+    SECTION("Vector2f")
+    {
+        Vector2f v(1.2345f, 2.3456f);
+        CHECK(fmt::format("{}", v) == "(1.2345, 2.3456)");
+        CHECK(fmt::format("{:.2f}", v) == "(1.23, 2.35)");
+    }
+
+    SECTION("Vector3f")
+    {
+        Vector3f v(1.2345f, 2.3456f, 3.4567f);
+        CHECK(fmt::format("{}", v) == "(1.2345, 2.3456, 3.4567)");
+        CHECK(fmt::format("{:.2f}", v) == "(1.23, 2.35, 3.46)");
+    }
+
+    SECTION("Vector4f")
+    {
+        Vector4f v(1.2345f, 2.3456f, 3.4567f, 4.5678f);
+        CHECK(fmt::format("{}", v) == "(1.2345, 2.3456, 3.4567, 4.5678)");
+        CHECK(fmt::format("{:.2f}", v) == "(1.23, 2.35, 3.46, 4.57)");
+    }
+}
+
+TEST_CASE("GLM Matrix Formatters", "[fmt]")
+{
+    SECTION("Matrix2f")
+    {
+        Matrix2f m = Matrix2f(1.0f);
+        CHECK(fmt::format("{}", m) == "[[1, 0], [0, 1]]");
+        CHECK(fmt::format("{:.1f}", m) == "[[1.0, 0.0], [0.0, 1.0]]");
+    }
+
+    SECTION("Matrix3f")
+    {
+        Matrix3f m = Matrix3f(1.0f);
+        CHECK(fmt::format("{}", m) == "[[1, 0, 0], [0, 1, 0], [0, 0, 1]]");
+        CHECK(fmt::format("{:.1f}", m) == "[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]");
+    }
+
+    SECTION("Matrix4f")
+    {
+        Matrix4f m = Matrix4f(1.0f);
+        CHECK(fmt::format("{}", m) == "[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]");
+        CHECK(fmt::format("{:.1f}", m) == "[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]");
+    }
+}
+
+TEST_CASE("GLM Quaternion Formatter", "[fmt]")
+{
+    QuaternionF q(1.0f, 0.0f, 0.0f, 0.0f);
+    CHECK(fmt::format("{}", q) == "(1, 0, 0, 0)");
+    CHECK(fmt::format("{:.2f}", q) == "(1.00, 0.00, 0.00, 0.00)");
+}
+
+TEST_CASE("Range Formatter", "[fmt]")
+{
+    Math::Range<float> range(1.2345f, 2.3456f);
+    CHECK(fmt::format("{}", range) == "[1.2345, 2.3456]");
+    CHECK(fmt::format("{:.2f}", range) == "[1.23, 2.35]");
+}
+
+TEST_CASE("Color Format Formatters", "[fmt]")
+{
+    SECTION("RGB565")
+    {
+        RGB565 color;
+        color.r = 31;
+        color.g = 63;
+        color.b = 31;
+        CHECK(fmt::format("{}", color) == "RGB565(r:31, g:63, b:31)");
+    }
+
+    SECTION("RGBA5551")
+    {
+        RGBA5551 color;
+        color.r = 31;
+        color.g = 31;
+        color.b = 31;
+        color.a = 1;
+        CHECK(fmt::format("{}", color) == "RGBA5551(r:31, g:31, b:31, a:1)");
+    }
+
+    SECTION("RGB10A2")
+    {
+        RGB10A2U color;
+        color.r = 1023;
+        color.g = 1023;
+        color.b = 1023;
+        color.a = 3;
+        CHECK(fmt::format("{}", color) == "RGB10A2(r:1023, g:1023, b:1023, a:3)");
+    }
+}
+
+TEST_CASE("DenseVector3i Formatter", "[fmt]")
+{
+    DenseVector3i<int32_t, false, true, 10> vec(1, 2, 3);
+    CHECK(fmt::format("{}", vec) == "DenseVector3i(1, 2, 3)");
+}
+
+TEST_CASE("Timestamp Formatter", "[fmt]")
+{
+    Timestamp ts((uint64_t)1000000);
+    CHECK(fmt::format("{}", ts) == "1000000ns");
+}
+
+TEST_CASE("Numeric Type Formatters", "[fmt]")
+{
+#ifndef __APPLE__
+    SECTION("float16")
+    {
+        float16 f(1.5f);
+        std::string formatted = fmt::format("{}", f);
+        CHECK((formatted == "1.5" || formatted == "1.500000"));
+        CHECK(fmt::format("{:.1f}", f) == "1.5");
+    }
+#endif
+
+    SECTION("int24")
+    {
+        OpenVulkano::int24 i(1000);
+        CHECK(fmt::format("{}", i) == "1000");
+    }
+
+    SECTION("uint24")
+    {
+        OpenVulkano::uint24 u(1000);
+        CHECK(fmt::format("{}", u) == "1000");
+    }
+}
+
+TEST_CASE("ByteSize Formatter", "[fmt]")
+{
+    SECTION("1000 bytes")
+    {
+        ByteSize size(1000);
+        CHECK(fmt::format("{}", size) == "1e+03 B");
+    }
+
+    SECTION("1024 bytes (1 kiB)")
+    {
+        ByteSize size(1024);
+        CHECK(fmt::format("{}", size) == "1 kiB");
+    }
+
+    SECTION("1 mebibyte")
+    {
+        ByteSize size(1024 * 1024);
+        CHECK(fmt::format("{}", size) == "1 MiB");
+    }
+
+    SECTION("Using unit constructors")
+    {
+        CHECK(fmt::format("{}", ByteSize(1, ByteSizeUnit(ByteSizeUnit::kiB))) == "1 kiB");
+        CHECK(fmt::format("{}", ByteSize(1, ByteSizeUnit(ByteSizeUnit::MiB))) == "1 MiB");
+    }
+}
+
+TEST_CASE("UUID Formatter", "[fmt]")
+{
+    UUID uuid = GenerateTimePrefixedCustomUUID();
+    std::string formatted = fmt::format("{}", uuid);
+    CHECK(formatted.length() == 36);
+    CHECK(formatted.find('-') != std::string::npos);
+}