From a57fe7676c4205c2a2865274de11098147b84e0d Mon Sep 17 00:00:00 2001
From: Milan Kriz <milan.kriz@eccam.com>
Date: Mon, 9 Sep 2024 13:50:22 +0200
Subject: [PATCH] [#2] Implement type wrappers for bool and floating point
 types

---
 runtime/src/zserio/BitSizeOfCalculator.cpp |   4 +-
 runtime/src/zserio/Types.h                 |  53 ++++-
 runtime/test/zserio/TypesTest.cpp          | 262 +++++++++++++--------
 3 files changed, 209 insertions(+), 110 deletions(-)

diff --git a/runtime/src/zserio/BitSizeOfCalculator.cpp b/runtime/src/zserio/BitSizeOfCalculator.cpp
index a6781bf..c377eb9 100644
--- a/runtime/src/zserio/BitSizeOfCalculator.cpp
+++ b/runtime/src/zserio/BitSizeOfCalculator.cpp
@@ -7,7 +7,7 @@
 namespace zserio
 {
 
-static const std::array<uint64_t, 2> VARIN16_MAX_VALUES = {
+static const std::array<uint64_t, 2> VARINT16_MAX_VALUES = {
         (UINT64_C(1) << (6)) - 1,
         (UINT64_C(1) << (6 + 8)) - 1,
 };
@@ -116,7 +116,7 @@ static uint64_t convertToAbsValue(T value)
 
 size_t bitSizeOfVarInt16(int16_t value)
 {
-    return bitSizeOfVarIntImpl(convertToAbsValue(value), VARIN16_MAX_VALUES, "varint16");
+    return bitSizeOfVarIntImpl(convertToAbsValue(value), VARINT16_MAX_VALUES, "varint16");
 }
 
 size_t bitSizeOfVarInt32(int32_t value)
diff --git a/runtime/src/zserio/Types.h b/runtime/src/zserio/Types.h
index 5dc56b1..d6d5aac 100644
--- a/runtime/src/zserio/Types.h
+++ b/runtime/src/zserio/Types.h
@@ -43,6 +43,12 @@ class TypeWrapper
     value_type m_value;
 };
 
+class BoolWrapper : public TypeWrapper<bool>
+{
+public:
+    using TypeWrapper<bool>::TypeWrapper;
+};
+
 template <typename VALUE_TYPE, BitSize BIT_SIZE = 8 * sizeof(VALUE_TYPE)>
 class IntWrapper : public TypeWrapper<VALUE_TYPE>
 {
@@ -50,8 +56,6 @@ class IntWrapper : public TypeWrapper<VALUE_TYPE>
     static_assert((BIT_SIZE + 7) / 8 <= sizeof(VALUE_TYPE), "BitSize doesn't fit to the VALUE_TYPE!");
 
 public:
-    using value_type = VALUE_TYPE;
-
     using TypeWrapper<VALUE_TYPE>::TypeWrapper;
 };
 
@@ -81,6 +85,20 @@ class VarIntWrapper : public TypeWrapper<VALUE_TYPE>
     using TypeWrapper<VALUE_TYPE>::TypeWrapper;
 };
 
+enum class FloatType : uint8_t
+{
+    FLOAT16,
+    FLOAT32,
+    FLOAT64
+};
+
+template <typename VALUE_TYPE, FloatType FLOAT_TYPE>
+class FloatWrapper : public TypeWrapper<VALUE_TYPE>
+{
+public:
+    using TypeWrapper<VALUE_TYPE>::TypeWrapper;
+};
+
 template <typename TYPE_WRAPPER>
 struct needs_range_check
 {};
@@ -88,6 +106,10 @@ struct needs_range_check
 template <typename TYPE_WRAPPER>
 inline constexpr bool needs_range_check_v = needs_range_check<TYPE_WRAPPER>::value;
 
+template <>
+struct needs_range_check<BoolWrapper> : std::false_type
+{};
+
 template <typename VALUE_TYPE, BitSize BIT_SIZE>
 struct needs_range_check<IntWrapper<VALUE_TYPE, BIT_SIZE>>
 {
@@ -105,11 +127,14 @@ struct needs_range_check<VarIntWrapper<VALUE_TYPE, VAR_TYPE>>
     static constexpr bool value = VAR_TYPE != VarIntType::VAR;
 };
 
+template <typename VALUE_TYPE, FloatType FLOAT_TYPE>
+struct needs_range_check<FloatWrapper<VALUE_TYPE, FLOAT_TYPE>> : std::false_type
+{};
+
 template <typename TYPE_WRAPPER>
 struct RangeChecker
 {
-    static constexpr void check(typename TYPE_WRAPPER::value_type value) noexcept(
-            !detail::needs_range_check_v<TYPE_WRAPPER>)
+    static constexpr void check(typename TYPE_WRAPPER::value_type value)
     {
         if constexpr (std::is_signed_v<typename TYPE_WRAPPER::value_type>)
         {
@@ -166,6 +191,20 @@ struct RangeChecker<DynIntWrapper<VALUE_TYPE>>
 
 } // namespace detail
 
+template <>
+struct Limits<detail::BoolWrapper>
+{
+    static constexpr bool min() noexcept
+    {
+        return false;
+    }
+
+    static constexpr bool max() noexcept
+    {
+        return true;
+    }
+};
+
 template <typename VALUE_TYPE, BitSize BIT_SIZE>
 struct Limits<detail::IntWrapper<VALUE_TYPE, BIT_SIZE>>
 {
@@ -360,6 +399,8 @@ constexpr typename TYPE_WRAPPER::value_type checked_cast(TYPE_WRAPPER wrapper, B
     return wrapper;
 }
 
+using Bool = detail::BoolWrapper;
+
 using Int8 = detail::IntWrapper<int8_t>;
 using Int16 = detail::IntWrapper<int16_t>;
 using Int32 = detail::IntWrapper<int32_t>;
@@ -514,6 +555,10 @@ using VarUInt = detail::VarIntWrapper<uint64_t, detail::VarIntType::VAR>;
 
 using VarSize = detail::VarIntWrapper<uint32_t, detail::VarIntType::VARSIZE>;
 
+using Float16 = detail::FloatWrapper<float, detail::FloatType::FLOAT16>;
+using Float32 = detail::FloatWrapper<float, detail::FloatType::FLOAT32>;
+using Float64 = detail::FloatWrapper<double, detail::FloatType::FLOAT64>;
+
 } // namespace zserio
 
 #endif // ifndef ZSERIO_TYPES_H_INC
diff --git a/runtime/test/zserio/TypesTest.cpp b/runtime/test/zserio/TypesTest.cpp
index fe93c44..6326147 100644
--- a/runtime/test/zserio/TypesTest.cpp
+++ b/runtime/test/zserio/TypesTest.cpp
@@ -9,23 +9,24 @@ void testSignedStdInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
-    static_assert(zserio::Limits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
+    static_assert(Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(Limits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
     static_assert(noexcept(checked_cast<T>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(checked_cast(std::declval<T>())), "shall be noexcept");
 
-    const T minValue(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+    const T minValue(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), minValue);
 
-    const T maxValue(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+    const T maxValue(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), maxValue);
 
-    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+    T checkedMin = checked_cast<T>(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), checked_cast(checkedMin));
 
-    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
+    T checkedMax = checked_cast<T>(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), checked_cast(checkedMax));
 
     T value;
     value = 0;
@@ -41,23 +42,24 @@ void testUnsignedStdInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
-    static_assert(zserio::Limits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
+    static_assert(Limits<T>::min() == std::numeric_limits<value_type>::min(), "shall be constexpr");
+    static_assert(Limits<T>::max() == std::numeric_limits<value_type>::max(), "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
     static_assert(noexcept(checked_cast<T>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(checked_cast(std::declval<T>())), "shall be noexcept");
 
-    const T minValue(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+    const T minValue(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), minValue);
 
-    const T maxValue(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+    const T maxValue(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), maxValue);
 
-    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+    T checkedMin = checked_cast<T>(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), checked_cast(checkedMin));
 
-    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
+    T checkedMax = checked_cast<T>(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), checked_cast(checkedMax));
 
     T value;
     value = 0;
@@ -74,24 +76,24 @@ void testSignedInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min() == MIN_VALUE, "shall be constexpr");
-    static_assert(zserio::Limits<T>::max() == MAX_VALUE, "shall be constexpr");
+    static_assert(Limits<T>::min() == MIN_VALUE, "shall be constexpr");
+    static_assert(Limits<T>::max() == MAX_VALUE, "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
-
     static_assert(IS_NOEXCEPT == noexcept(checked_cast<T>(std::declval<value_type>())), "unexpected noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(checked_cast(std::declval<T>())), "unexpected noexcept");
 
-    const T minValue(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+    const T minValue(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), minValue);
 
-    const T maxValue(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+    const T maxValue(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), maxValue);
 
-    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+    T checkedMin = checked_cast<T>(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), checked_cast(checkedMin));
 
-    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
+    T checkedMax = checked_cast<T>(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), checked_cast(checkedMax));
 
     T value;
     ASSERT_EQ(0, value);
@@ -102,12 +104,12 @@ void testSignedInt()
 
     if constexpr (!IS_NOEXCEPT)
     {
-        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::min() - 1), OutOfRangeException);
-        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::max() + 1), OutOfRangeException);
+        ASSERT_THROW(checked_cast<T>(Limits<T>::min() - 1), OutOfRangeException);
+        ASSERT_THROW(checked_cast<T>(Limits<T>::max() + 1), OutOfRangeException);
         const T underMin = minValue - 1;
-        ASSERT_THROW(zserio::checked_cast(underMin), OutOfRangeException);
+        ASSERT_THROW(checked_cast(underMin), OutOfRangeException);
         const T overMax = maxValue + 1;
-        ASSERT_THROW(zserio::checked_cast(overMax), OutOfRangeException);
+        ASSERT_THROW(checked_cast(overMax), OutOfRangeException);
     }
 }
 
@@ -116,36 +118,37 @@ void testUnsignedInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min() == 0, "shall be constexpr");
-    static_assert(zserio::Limits<T>::max() == MAX_VALUE, "shall be constexpr");
+    static_assert(Limits<T>::min() == 0, "shall be constexpr");
+    static_assert(Limits<T>::max() == MAX_VALUE, "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
     static_assert(IS_NOEXCEPT == noexcept(checked_cast<T>(std::declval<value_type>())), "unexpected noexcept");
+    static_assert(IS_NOEXCEPT == noexcept(checked_cast(std::declval<T>())), "unexpected noexcept");
 
-    const T minValue(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), minValue);
+    const T minValue(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), minValue);
 
-    const T maxValue(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), maxValue);
+    const T maxValue(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), maxValue);
 
-    T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min());
-    ASSERT_EQ(zserio::Limits<T>::min(), checkedMin);
+    T checkedMin = checked_cast<T>(Limits<T>::min());
+    ASSERT_EQ(Limits<T>::min(), checked_cast(checkedMin));
 
-    T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max());
-    ASSERT_EQ(zserio::Limits<T>::max(), checkedMax);
+    T checkedMax = checked_cast<T>(Limits<T>::max());
+    ASSERT_EQ(Limits<T>::max(), checked_cast(checkedMax));
 
     T value;
     ASSERT_EQ(0, value);
     value = 1;
     ASSERT_EQ(1, value);
-    value = zserio::Limits<T>::max() - 1;
-    ASSERT_EQ(zserio::Limits<T>::max() - 1, value);
+    value = Limits<T>::max() - 1;
+    ASSERT_EQ(Limits<T>::max() - 1, value);
 
     if constexpr (!IS_NOEXCEPT)
     {
-        ASSERT_THROW(zserio::checked_cast<T>(zserio::Limits<T>::max() + 1), OutOfRangeException);
+        ASSERT_THROW(checked_cast<T>(Limits<T>::max() + 1), OutOfRangeException);
         const T overMax = maxValue + 1;
-        ASSERT_THROW(zserio::checked_cast(overMax), OutOfRangeException);
+        ASSERT_THROW(checked_cast(overMax), OutOfRangeException);
     }
 }
 
@@ -154,29 +157,30 @@ void testSignedDynInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min(8) == -128, "shall be constexpr");
-    static_assert(zserio::Limits<T>::max(8) == 127, "shall be constexpr");
+    static_assert(Limits<T>::min(8) == -128, "shall be constexpr");
+    static_assert(Limits<T>::max(8) == 127, "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
     static_assert(!noexcept(checked_cast<T>(std::declval<value_type>(), std::declval<BitSize>())),
             "shall not be noexcept");
+    static_assert(!noexcept(checked_cast(std::declval<T>(), std::declval<BitSize>())), "shall not be noexcept");
 
-    ASSERT_THROW(zserio::checked_cast<T>(0, 0), OutOfRangeException);
-    ASSERT_THROW(zserio::checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+    ASSERT_THROW(checked_cast<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
 
     for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
     {
-        const T minValue(zserio::Limits<T>::min(numBits));
-        ASSERT_EQ(zserio::Limits<T>::min(numBits), minValue);
+        const T minValue(Limits<T>::min(numBits));
+        ASSERT_EQ(Limits<T>::min(numBits), minValue);
 
-        const T maxValue(zserio::Limits<T>::max(numBits));
-        ASSERT_EQ(zserio::Limits<T>::max(numBits), maxValue);
+        const T maxValue(Limits<T>::max(numBits));
+        ASSERT_EQ(Limits<T>::max(numBits), maxValue);
 
-        T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min(numBits), numBits);
-        ASSERT_EQ(zserio::Limits<T>::min(numBits), checkedMin);
+        T checkedMin = checked_cast<T>(Limits<T>::min(numBits), numBits);
+        ASSERT_EQ(Limits<T>::min(numBits), checked_cast(checkedMin, numBits));
 
-        T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max(numBits), numBits);
-        ASSERT_EQ(zserio::Limits<T>::max(numBits), checkedMax);
+        T checkedMax = checked_cast<T>(Limits<T>::max(numBits), numBits);
+        ASSERT_EQ(Limits<T>::max(numBits), checked_cast(checkedMax, numBits));
 
         T value;
         ASSERT_EQ(0, value);
@@ -187,15 +191,12 @@ void testSignedDynInt()
 
         if (numBits < sizeof(value_type) * 8)
         {
-            ASSERT_THROW(
-                    zserio::checked_cast<T>(zserio::Limits<T>::min(numBits) - 1, numBits), OutOfRangeException)
-                    << numBits;
-            ASSERT_THROW(
-                    zserio::checked_cast<T>(zserio::Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            ASSERT_THROW(checked_cast<T>(Limits<T>::min(numBits) - 1, numBits), OutOfRangeException) << numBits;
+            ASSERT_THROW(checked_cast<T>(Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
             const T underMin = minValue - 1;
-            ASSERT_THROW(zserio::checked_cast(underMin, numBits), OutOfRangeException);
+            ASSERT_THROW(checked_cast(underMin, numBits), OutOfRangeException);
             const T overMax = maxValue + 1;
-            ASSERT_THROW(zserio::checked_cast(overMax, numBits), OutOfRangeException);
+            ASSERT_THROW(checked_cast(overMax, numBits), OutOfRangeException);
         }
     }
 }
@@ -205,48 +206,94 @@ void testUnsignedDynInt()
 {
     using value_type = typename T::value_type;
 
-    static_assert(zserio::Limits<T>::min(8) == 0, "shall be constexpr");
-    static_assert(zserio::Limits<T>::max(8) == 255, "shall be constexpr");
+    static_assert(Limits<T>::min(8) == 0, "shall be constexpr");
+    static_assert(Limits<T>::max(8) == 255, "shall be constexpr");
 
     static_assert(std::is_nothrow_constructible_v<T, value_type>, "shall be noexcept");
     static_assert(!noexcept(checked_cast<T>(std::declval<value_type>(), std::declval<BitSize>())),
             "shall not be noexcept");
+    static_assert(!noexcept(checked_cast(std::declval<T>(), std::declval<BitSize>())), "shall not be noexcept");
 
-    ASSERT_THROW(zserio::checked_cast<T>(0, 0), OutOfRangeException);
-    ASSERT_THROW(zserio::checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
+    ASSERT_THROW(checked_cast<T>(0, 0), OutOfRangeException);
+    ASSERT_THROW(checked_cast<T>(0, sizeof(value_type) * 8 + 1), OutOfRangeException);
 
     for (BitSize numBits = 1; numBits <= sizeof(value_type) * 8; ++numBits)
     {
-        const T minValue(zserio::Limits<T>::min(numBits));
-        ASSERT_EQ(zserio::Limits<T>::min(numBits), minValue);
+        const T minValue(Limits<T>::min(numBits));
+        ASSERT_EQ(Limits<T>::min(numBits), minValue);
 
-        const T maxValue(zserio::Limits<T>::max(numBits));
-        ASSERT_EQ(zserio::Limits<T>::max(numBits), maxValue);
+        const T maxValue(Limits<T>::max(numBits));
+        ASSERT_EQ(Limits<T>::max(numBits), maxValue);
 
-        T checkedMin = zserio::checked_cast<T>(zserio::Limits<T>::min(numBits), numBits);
-        ASSERT_EQ(zserio::Limits<T>::min(numBits), checkedMin);
+        T checkedMin = checked_cast<T>(Limits<T>::min(numBits), numBits);
+        ASSERT_EQ(Limits<T>::min(numBits), checked_cast(checkedMin, numBits));
 
-        T checkedMax = zserio::checked_cast<T>(zserio::Limits<T>::max(numBits), numBits);
-        ASSERT_EQ(zserio::Limits<T>::max(numBits), checkedMax);
+        T checkedMax = checked_cast<T>(Limits<T>::max(numBits), numBits);
+        ASSERT_EQ(Limits<T>::max(numBits), checked_cast(checkedMax, numBits));
 
         T value;
         ASSERT_EQ(0, value);
         value = 1;
         ASSERT_EQ(1, value);
-        value = zserio::Limits<T>::max(numBits) - 1;
-        ASSERT_EQ(zserio::Limits<T>::max(numBits) - 1, value);
+        value = Limits<T>::max(numBits) - 1;
+        ASSERT_EQ(Limits<T>::max(numBits) - 1, value);
 
         if (numBits < sizeof(value_type) * 8)
         {
-            ASSERT_THROW(
-                    zserio::checked_cast<T>(zserio::Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
+            ASSERT_THROW(checked_cast<T>(Limits<T>::max(numBits) + 1, numBits), OutOfRangeException);
             const T overMax = maxValue + 1;
-            ASSERT_THROW(zserio::checked_cast(overMax, numBits), OutOfRangeException);
+            ASSERT_THROW(checked_cast(overMax, numBits), OutOfRangeException);
         }
     }
 }
 
-TEST(TypesTest, signedStdInts)
+template <typename FLOAT_TYPE>
+void testFloat()
+{
+    using value_type = typename FLOAT_TYPE::value_type;
+
+    static_assert(std::is_nothrow_constructible_v<FLOAT_TYPE, value_type>, "shall be noexcept");
+    static_assert(noexcept(checked_cast<FLOAT_TYPE>(std::declval<value_type>())), "shall be noexcept");
+    static_assert(noexcept(checked_cast(std::declval<FLOAT_TYPE>())), "shall be noexcept");
+
+    FLOAT_TYPE value;
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(0.0), value);
+    value = static_cast<value_type>(1.0);
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(1.0), value);
+    value = static_cast<value_type>(0.0);
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(0.0), value);
+
+    FLOAT_TYPE checked_value = checked_cast<FLOAT_TYPE>(static_cast<value_type>(1.0));
+    ASSERT_DOUBLE_EQ(static_cast<value_type>(1.0), checked_cast(checked_value));
+}
+
+TEST(TypesTest, boolType)
+{
+    static_assert(std::is_nothrow_constructible_v<Bool, bool>, "shall be noexcept");
+    static_assert(noexcept(checked_cast<Bool>(std::declval<bool>())), "shall be noexcept");
+    static_assert(noexcept(checked_cast(std::declval<Bool>())), "shall be noexcept");
+
+    const Bool minValue(Limits<Bool>::min());
+    ASSERT_EQ(Limits<Bool>::min(), minValue);
+
+    const Bool maxValue(Limits<Bool>::max());
+    ASSERT_EQ(Limits<Bool>::max(), maxValue);
+
+    Bool checkedMin = checked_cast<Bool>(Limits<Bool>::min());
+    ASSERT_EQ(Limits<Bool>::min(), checked_cast(checkedMin));
+
+    Bool checkedMax = checked_cast<Bool>(Limits<Bool>::max());
+    ASSERT_EQ(Limits<Bool>::max(), checked_cast(checkedMax));
+
+    Bool value;
+    ASSERT_EQ(false, value);
+    value = true;
+    ASSERT_EQ(true, value);
+    value = false;
+    ASSERT_EQ(false, value);
+}
+
+TEST(TypesTest, signedStdIntTypes)
 {
     testSignedStdInt<Int8>();
     testSignedStdInt<Int16>();
@@ -254,7 +301,7 @@ TEST(TypesTest, signedStdInts)
     testSignedStdInt<Int64>();
 }
 
-TEST(TypesTest, unsignedStdInts)
+TEST(TypesTest, unsignedStdIntTypes)
 {
     testUnsignedStdInt<UInt8>();
     testUnsignedStdInt<UInt16>();
@@ -262,7 +309,7 @@ TEST(TypesTest, unsignedStdInts)
     testUnsignedStdInt<UInt64>();
 }
 
-TEST(TypesTest, signedBitFields)
+TEST(TypesTest, signedBitFieldTypes)
 {
     testSignedInt<Int1, -1, 0>();
     testSignedInt<Int2, -2, 1>();
@@ -326,7 +373,7 @@ TEST(TypesTest, signedBitFields)
     testSignedInt<Int63, -4611686018427387904LL, 4611686018427387903LL>();
 }
 
-TEST(TypesTest, unsignedBitFields)
+TEST(TypesTest, unsignedBitFieldTypes)
 {
     testUnsignedInt<UInt1, 1ULL>();
     testUnsignedInt<UInt2, 3ULL>();
@@ -390,7 +437,23 @@ TEST(TypesTest, unsignedBitFields)
     testUnsignedInt<UInt63, 9223372036854775807ULL>();
 }
 
-TEST(TypesTest, signedVarInts)
+TEST(TypesTest, signedDynIntTypes)
+{
+    testSignedDynInt<DynInt8>();
+    testSignedDynInt<DynInt16>();
+    testSignedDynInt<DynInt32>();
+    testSignedDynInt<DynInt64>();
+}
+
+TEST(TypesTest, unsignedDynIntTypes)
+{
+    testUnsignedDynInt<DynUInt8>();
+    testUnsignedDynInt<DynUInt16>();
+    testUnsignedDynInt<DynUInt32>();
+    testUnsignedDynInt<DynUInt64>();
+}
+
+TEST(TypesTest, signedVarIntTypes)
 {
     testSignedInt<VarInt16, -16383, 16383>();
     testSignedInt<VarInt32, -268435455, 268435455>();
@@ -398,7 +461,7 @@ TEST(TypesTest, signedVarInts)
     testSignedInt<VarInt, INT64_MIN, INT64_MAX, true>();
 }
 
-TEST(TypesTest, unsignedVarInts)
+TEST(TypesTest, unsignedVarIntTypes)
 {
     testUnsignedInt<VarUInt16, 32767>();
     testUnsignedInt<VarUInt32, 536870911>();
@@ -407,20 +470,11 @@ TEST(TypesTest, unsignedVarInts)
     testUnsignedInt<VarSize, 2147483647>();
 }
 
-TEST(TypesTest, signedDynInts)
-{
-    testSignedDynInt<DynInt8>();
-    testSignedDynInt<DynInt16>();
-    testSignedDynInt<DynInt32>();
-    testSignedDynInt<DynInt64>();
-}
-
-TEST(TypesTest, unsignedDynInts)
+TEST(TypesTest, floatTypes)
 {
-    testUnsignedDynInt<DynUInt8>();
-    testUnsignedDynInt<DynUInt16>();
-    testUnsignedDynInt<DynUInt32>();
-    testUnsignedDynInt<DynUInt64>();
+    testFloat<Float16>();
+    testFloat<Float32>();
+    testFloat<Float64>();
 }
 
 } // namespace zserio