From 64ac3f8db61e5c4211de493ad4ed63d94a9d3041 Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 30 Nov 2024 11:52:50 -0500
Subject: [PATCH 1/9] add new test

---
 au/BUILD.bazel                                |  12 ++
 ...antity_runtime_conversion_checkers_test.cc | 165 ++++++++++++++++++
 2 files changed, 177 insertions(+)
 create mode 100644 au/code/au/quantity_runtime_conversion_checkers_test.cc

diff --git a/au/BUILD.bazel b/au/BUILD.bazel
index f5d34c47..d838684c 100644
--- a/au/BUILD.bazel
+++ b/au/BUILD.bazel
@@ -493,6 +493,18 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "quantity_runtime_conversion_checkers_test",
+    size = "small",
+    srcs = ["code/au/quantity_runtime_conversion_checkers_test.cc"],
+    deps = [
+        ":quantity",
+        ":testing",
+        ":units",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "quantity_point",
     hdrs = ["code/au/quantity_point.hh"],
diff --git a/au/code/au/quantity_runtime_conversion_checkers_test.cc b/au/code/au/quantity_runtime_conversion_checkers_test.cc
new file mode 100644
index 00000000..3e9d354b
--- /dev/null
+++ b/au/code/au/quantity_runtime_conversion_checkers_test.cc
@@ -0,0 +1,165 @@
+// Copyright 2024 Aurora Operations, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <random>
+#include <tuple>
+#include <type_traits>
+
+#include "au/quantity.hh"
+#include "au/testing.hh"
+#include "au/units/inches.hh"
+#include "au/units/meters.hh"
+#include "au/units/miles.hh"
+#include "au/units/yards.hh"
+#include "gtest/gtest.h"
+
+namespace au {
+namespace {
+
+using ::testing::StaticAssertTypeEq;
+
+template <typename T>
+class RandomValueGenerator {
+ public:
+    RandomValueGenerator(std::uint64_t seed) : engine_{seed} {}
+
+    T next_value() {
+        static std::uniform_int_distribution<std::uint64_t> uniform{};
+        return static_cast<T>(uniform(engine_));
+    }
+
+ private:
+    std::mt19937_64 engine_;
+};
+
+template <template <class...> class Tuple, typename... Packs>
+struct CartesianProductImpl;
+template <template <class...> class Tuple, typename... Packs>
+using CartesianProduct = typename CartesianProductImpl<Tuple, Packs...>::type;
+template <template <class...> class Tuple, template <class...> class Pack, typename... Ts>
+struct CartesianProductImpl<Tuple, Pack<Ts...>> : stdx::type_identity<Pack<Tuple<Ts>...>> {};
+
+template <typename... Packs>
+struct FlattenImpl;
+template <typename... Packs>
+using Flatten = typename FlattenImpl<Packs...>::type;
+template <template <class...> class Pack, typename... Ts>
+struct FlattenImpl<Pack<Ts...>> : stdx::type_identity<Pack<Ts...>> {};
+template <template <class...> class Pack, typename... Ts, typename... Us, typename... Packs>
+struct FlattenImpl<Pack<Ts...>, Pack<Us...>, Packs...>
+    : stdx::type_identity<Flatten<Pack<Ts..., Us...>, Packs...>> {};
+
+template <typename T, typename... Packs>
+struct PrependToEachImpl;
+template <typename T, typename... Packs>
+using PrependToEach = typename PrependToEachImpl<T, Packs...>::type;
+template <template <class...> class Pack, typename T, typename... Ts>
+struct PrependToEachImpl<T, Pack<Ts...>> {
+    using type = Pack<detail::PrependT<Ts, T>...>;
+};
+
+template <template <class...> class Tuple,
+          template <class...>
+          class Pack,
+          typename... Ts,
+          typename... Packs>
+struct CartesianProductImpl<Tuple, Pack<Ts...>, Packs...> {
+    using type = Flatten<PrependToEach<Ts, CartesianProduct<Tuple, Packs...>>...>;
+};
+
+TEST(PrependToEach, PrependsElementToEachPack) {
+    StaticAssertTypeEq<PrependToEach<int, ::testing::Types<>>, ::testing::Types<>>();
+    StaticAssertTypeEq<
+        PrependToEach<int, ::testing::Types<std::tuple<char>, std::tuple<double, float>>>,
+        ::testing::Types<std::tuple<int, char>, std::tuple<int, double, float>>>();
+}
+
+TEST(Flatten, ConcatenatesPacksOfSameType) {
+    StaticAssertTypeEq<Flatten<::testing::Types<>>, ::testing::Types<>>();
+    StaticAssertTypeEq<Flatten<::testing::Types<>, ::testing::Types<>>, ::testing::Types<>>();
+}
+
+TEST(CartesianProduct, AppliesPackToEachElementOfSinglePack) {
+    StaticAssertTypeEq<CartesianProduct<std::tuple, ::testing::Types<int, double, float>>,
+                       ::testing::Types<std::tuple<int>, std::tuple<double>, std::tuple<float>>>();
+}
+
+TEST(CartesianProduct, CombinesMultiplePacksIntoASinglePackWithAllCombinations) {
+    StaticAssertTypeEq<
+        CartesianProduct<std::tuple, ::testing::Types<int, double>, ::testing::Types<float, char>>,
+        ::testing::Types<std::tuple<int, float>,
+                         std::tuple<int, char>,
+                         std::tuple<double, float>,
+                         std::tuple<double, char>>>();
+}
+
+TEST(CartesianProduct, CanHandleMultipleLayers) {
+    struct A_1;
+    struct A_2;
+
+    struct B_1;
+    struct B_2;
+
+    struct C_1;
+    struct C_2;
+
+    StaticAssertTypeEq<CartesianProduct<std::tuple,
+
+                                        ::testing::Types<A_1, A_2>,
+                                        ::testing::Types<B_1, B_2>,
+                                        ::testing::Types<C_1, C_2>>,
+
+                       ::testing::Types<std::tuple<A_1, B_1, C_1>,
+                                        std::tuple<A_1, B_1, C_2>,
+                                        std::tuple<A_1, B_2, C_1>,
+                                        std::tuple<A_1, B_2, C_2>,
+                                        std::tuple<A_2, B_1, C_1>,
+                                        std::tuple<A_2, B_1, C_2>,
+                                        std::tuple<A_2, B_2, C_1>,
+                                        std::tuple<A_2, B_2, C_2>>>();
+}
+
+template <typename T>
+class QuantityRuntimeConversionChecker : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(QuantityRuntimeConversionChecker);
+
+TYPED_TEST_P(QuantityRuntimeConversionChecker, RoundTripIsIdentityIffConversionNotLossy) {
+    using Rep = std::tuple_element_t<0, TypeParam>;
+    constexpr auto destination_unit = std::tuple_element_t<1, TypeParam>{};
+    RandomValueGenerator<Rep> generator{9876543210u};
+    for (auto i = 0u; i < 1'000'000u; ++i) {
+        const auto value = meters(generator.next_value());
+
+        const bool expect_loss = is_conversion_lossy(value, destination_unit);
+
+        const auto round_trip = value.coerce_as(destination_unit).coerce_as(meters);
+        const bool actual_loss = (value != round_trip);
+
+        EXPECT_EQ(expect_loss, actual_loss) << "Value: " << value << " Round trip: " << round_trip;
+    }
+}
+
+REGISTER_TYPED_TEST_SUITE_P(QuantityRuntimeConversionChecker,
+                            RoundTripIsIdentityIffConversionNotLossy);
+
+using IntTypes =
+    ::testing::Types<uint64_t, int64_t, uint32_t, int32_t, uint16_t, int16_t, uint8_t, int8_t>;
+using DestinationUnits = ::testing::Types<Inches, Yards, Miles>;
+
+using TypesToTest = CartesianProduct<std::tuple, IntTypes, DestinationUnits>;
+INSTANTIATE_TYPED_TEST_SUITE_P(X, QuantityRuntimeConversionChecker, TypesToTest, );
+
+}  // namespace
+}  // namespace au

From ecfc53824ef5eaabd193f985d6cb420f4592d81f Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sun, 1 Dec 2024 14:07:22 -0500
Subject: [PATCH 2/9] Move it to `fuzz`

---
 au/BUILD.bazel                                |  12 --
 fuzz/BUILD.bazel                              |  48 ++++++++
 fuzz/quantity_runtime_conversion_check.cc     | 113 ++++++++++++++++++
 fuzz/quantity_runtime_conversion_checkers.hh  |  88 ++++++++++++++
 ...antity_runtime_conversion_checkers_test.cc |  52 +-------
 5 files changed, 251 insertions(+), 62 deletions(-)
 create mode 100644 fuzz/BUILD.bazel
 create mode 100644 fuzz/quantity_runtime_conversion_check.cc
 create mode 100644 fuzz/quantity_runtime_conversion_checkers.hh
 rename {au/code/au => fuzz}/quantity_runtime_conversion_checkers_test.cc (70%)

diff --git a/au/BUILD.bazel b/au/BUILD.bazel
index d838684c..f5d34c47 100644
--- a/au/BUILD.bazel
+++ b/au/BUILD.bazel
@@ -493,18 +493,6 @@ cc_test(
     ],
 )
 
-cc_test(
-    name = "quantity_runtime_conversion_checkers_test",
-    size = "small",
-    srcs = ["code/au/quantity_runtime_conversion_checkers_test.cc"],
-    deps = [
-        ":quantity",
-        ":testing",
-        ":units",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
 cc_library(
     name = "quantity_point",
     hdrs = ["code/au/quantity_point.hh"],
diff --git a/fuzz/BUILD.bazel b/fuzz/BUILD.bazel
new file mode 100644
index 00000000..6e0684c4
--- /dev/null
+++ b/fuzz/BUILD.bazel
@@ -0,0 +1,48 @@
+# Copyright 2022 Aurora Operations, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
+
+cc_binary(
+    name = "quantity_runtime_conversion_check",
+    testonly = True,
+    srcs = ["quantity_runtime_conversion_check.cc"],
+    deps = [
+        ":quantity_runtime_conversion_checkers",
+        "//au:testing",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "quantity_runtime_conversion_checkers",
+    testonly = True,
+    hdrs = ["quantity_runtime_conversion_checkers.hh"],
+    deps = [
+        "//au",
+        "@com_google_googletest//:gtest",
+    ],
+)
+
+cc_test(
+    name = "quantity_runtime_conversion_checkers_test",
+    size = "small",
+    srcs = ["quantity_runtime_conversion_checkers_test.cc"],
+    deps = [
+        ":quantity_runtime_conversion_checkers",
+        "//au",
+        "//au:testing",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
new file mode 100644
index 00000000..f98d1786
--- /dev/null
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -0,0 +1,113 @@
+// Copyright 2024 Aurora Operations, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "au/testing.hh"
+#include "au/units/inches.hh"
+#include "au/units/meters.hh"
+#include "au/units/miles.hh"
+#include "au/units/yards.hh"
+#include "fuzz/quantity_runtime_conversion_checkers.hh"
+#include "gtest/gtest.h"
+
+namespace au {
+
+template <typename T>
+struct Tag {};
+
+template <typename T, typename U>
+constexpr bool operator==(Tag<T>, Tag<U>) {
+    return std::is_same<T, U>::value;
+}
+
+template <typename T>
+T type_of(const Tag<T> &);
+
+template <typename T>
+struct UnwrapTagImpl : stdx::type_identity<T> {};
+template <typename T>
+using UnwrapTag = typename UnwrapTagImpl<T>::type;
+template <typename T>
+struct UnwrapTagImpl<Tag<T>> : stdx::type_identity<T> {};
+
+template <typename... Ts>
+struct ListImpl;
+template <typename... Ts>
+using List = typename ListImpl<Ts...>::type;
+template <typename... Ts>
+struct ListImpl : stdx::type_identity<std::tuple<Tag<Ts>...>> {};
+
+using IntTypes = List<uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t>;
+using Units = List<Inches, Meters, Miles, Yards>;
+
+template <typename PackT>
+struct GeneratorForImpl;
+template <typename PackT>
+using GeneratorFor = typename GeneratorForImpl<PackT>::type;
+template <template <class...> class Pack, typename... Ts>
+struct GeneratorForImpl<Pack<Ts...>>
+    : stdx::type_identity<RandomValueGenerators<UnwrapTag<Ts>...>> {};
+
+template <typename ListT>
+struct ForEach;
+template <>
+struct ForEach<std::tuple<>> {
+    template <typename Func>
+    void operator()(const Func &) {}
+};
+template <typename T, typename... Ts>
+struct ForEach<std::tuple<T, Ts...>> {
+    template <typename Func>
+    void operator()(const Func &f) const {
+        f(T{});
+        ForEach<std::tuple<Ts...>>{}(f);
+    }
+};
+
+TEST(RuntimeConversionCheckers, Fuzz) {
+    GeneratorFor<IntTypes> generators{9876543210u};
+    constexpr auto for_each_params = ForEach<CartesianProduct<std::tuple, IntTypes, Units>>{};
+    for (auto i = 0u; i < 100'000u; ++i) {
+        for_each_params([&](auto source_params) {
+            using IntT = decltype(type_of(std::get<0>(source_params)));
+            using UnitT = decltype(type_of(std::get<1>(source_params)));
+
+            const auto value = make_quantity<UnitT>(generators.template next_value<IntT>());
+
+            for_each_params([&](auto dest_params) {
+                using DestIntT = decltype(type_of(std::get<0>(dest_params)));
+                using DestUnitT = decltype(type_of(std::get<1>(dest_params)));
+
+                if (source_params == dest_params) {
+                    return;
+                }
+
+                const bool expect_loss = is_conversion_lossy<DestIntT>(value, DestUnitT{});
+
+                const auto round_trip = value.template coerce_as<DestIntT>(DestUnitT{})
+                                            .template coerce_as<IntT>(UnitT{});
+                const bool actual_loss = (value != round_trip);
+
+                if (expect_loss != actual_loss) {
+                    std::cout << "Error found for <" << typeid(IntT).name() << ">("
+                              << unit_label(UnitT{}) << ") -> <" << typeid(DestIntT).name() << ">("
+                              << unit_label(DestUnitT{}) << ")! "
+                              << "Value: " << value << " Round trip: " << round_trip << std::endl;
+                    std::terminate();
+                }
+            });
+        });
+    }
+}
+
+}  // namespace au
diff --git a/fuzz/quantity_runtime_conversion_checkers.hh b/fuzz/quantity_runtime_conversion_checkers.hh
new file mode 100644
index 00000000..b736dc20
--- /dev/null
+++ b/fuzz/quantity_runtime_conversion_checkers.hh
@@ -0,0 +1,88 @@
+// Copyright 2024 Aurora Operations, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstdint>
+#include <random>
+
+#include "au/stdx/type_traits.hh"
+#include "au/utility/type_traits.hh"
+
+namespace au {
+
+template <typename T>
+class RandomValueGenerator {
+ public:
+    RandomValueGenerator(std::uint64_t seed) : engine_{seed} {}
+
+    T next_value() {
+        static std::uniform_int_distribution<std::uint64_t> uniform{};
+        return static_cast<T>(uniform(engine_));
+    }
+
+ private:
+    std::mt19937_64 engine_;
+};
+
+template <typename... Ts>
+class RandomValueGenerators {
+ public:
+    RandomValueGenerators(std::uint64_t seed) : generators_{RandomValueGenerator<Ts>{seed}...} {}
+
+    template <typename T>
+    T next_value() {
+        return std::get<RandomValueGenerator<T>>(generators_).next_value();
+    }
+
+ private:
+    std::tuple<RandomValueGenerator<Ts>...> generators_;
+};
+
+template <template <class...> class Tuple, typename... Packs>
+struct CartesianProductImpl;
+template <template <class...> class Tuple, typename... Packs>
+using CartesianProduct = typename CartesianProductImpl<Tuple, Packs...>::type;
+template <template <class...> class Tuple, template <class...> class Pack, typename... Ts>
+struct CartesianProductImpl<Tuple, Pack<Ts...>> : stdx::type_identity<Pack<Tuple<Ts>...>> {};
+
+template <typename... Packs>
+struct FlattenImpl;
+template <typename... Packs>
+using Flatten = typename FlattenImpl<Packs...>::type;
+template <template <class...> class Pack, typename... Ts>
+struct FlattenImpl<Pack<Ts...>> : stdx::type_identity<Pack<Ts...>> {};
+template <template <class...> class Pack, typename... Ts, typename... Us, typename... Packs>
+struct FlattenImpl<Pack<Ts...>, Pack<Us...>, Packs...>
+    : stdx::type_identity<Flatten<Pack<Ts..., Us...>, Packs...>> {};
+
+template <typename T, typename... Packs>
+struct PrependToEachImpl;
+template <typename T, typename... Packs>
+using PrependToEach = typename PrependToEachImpl<T, Packs...>::type;
+template <template <class...> class Pack, typename T, typename... Ts>
+struct PrependToEachImpl<T, Pack<Ts...>> {
+    using type = Pack<detail::PrependT<Ts, T>...>;
+};
+
+template <template <class...> class Tuple,
+          template <class...>
+          class Pack,
+          typename... Ts,
+          typename... Packs>
+struct CartesianProductImpl<Tuple, Pack<Ts...>, Packs...> {
+    using type = Flatten<PrependToEach<Ts, CartesianProduct<Tuple, Packs...>>...>;
+};
+
+}  // namespace au
diff --git a/au/code/au/quantity_runtime_conversion_checkers_test.cc b/fuzz/quantity_runtime_conversion_checkers_test.cc
similarity index 70%
rename from au/code/au/quantity_runtime_conversion_checkers_test.cc
rename to fuzz/quantity_runtime_conversion_checkers_test.cc
index 3e9d354b..ab0b3885 100644
--- a/au/code/au/quantity_runtime_conversion_checkers_test.cc
+++ b/fuzz/quantity_runtime_conversion_checkers_test.cc
@@ -12,7 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <random>
+#include "fuzz/quantity_runtime_conversion_checkers.hh"
+
 #include <tuple>
 #include <type_traits>
 
@@ -29,55 +30,6 @@ namespace {
 
 using ::testing::StaticAssertTypeEq;
 
-template <typename T>
-class RandomValueGenerator {
- public:
-    RandomValueGenerator(std::uint64_t seed) : engine_{seed} {}
-
-    T next_value() {
-        static std::uniform_int_distribution<std::uint64_t> uniform{};
-        return static_cast<T>(uniform(engine_));
-    }
-
- private:
-    std::mt19937_64 engine_;
-};
-
-template <template <class...> class Tuple, typename... Packs>
-struct CartesianProductImpl;
-template <template <class...> class Tuple, typename... Packs>
-using CartesianProduct = typename CartesianProductImpl<Tuple, Packs...>::type;
-template <template <class...> class Tuple, template <class...> class Pack, typename... Ts>
-struct CartesianProductImpl<Tuple, Pack<Ts...>> : stdx::type_identity<Pack<Tuple<Ts>...>> {};
-
-template <typename... Packs>
-struct FlattenImpl;
-template <typename... Packs>
-using Flatten = typename FlattenImpl<Packs...>::type;
-template <template <class...> class Pack, typename... Ts>
-struct FlattenImpl<Pack<Ts...>> : stdx::type_identity<Pack<Ts...>> {};
-template <template <class...> class Pack, typename... Ts, typename... Us, typename... Packs>
-struct FlattenImpl<Pack<Ts...>, Pack<Us...>, Packs...>
-    : stdx::type_identity<Flatten<Pack<Ts..., Us...>, Packs...>> {};
-
-template <typename T, typename... Packs>
-struct PrependToEachImpl;
-template <typename T, typename... Packs>
-using PrependToEach = typename PrependToEachImpl<T, Packs...>::type;
-template <template <class...> class Pack, typename T, typename... Ts>
-struct PrependToEachImpl<T, Pack<Ts...>> {
-    using type = Pack<detail::PrependT<Ts, T>...>;
-};
-
-template <template <class...> class Tuple,
-          template <class...>
-          class Pack,
-          typename... Ts,
-          typename... Packs>
-struct CartesianProductImpl<Tuple, Pack<Ts...>, Packs...> {
-    using type = Flatten<PrependToEach<Ts, CartesianProduct<Tuple, Packs...>>...>;
-};
-
 TEST(PrependToEach, PrependsElementToEachPack) {
     StaticAssertTypeEq<PrependToEach<int, ::testing::Types<>>, ::testing::Types<>>();
     StaticAssertTypeEq<

From a39530ab6b23fc10b15b08513afec15d93ec3612 Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Mon, 2 Dec 2024 08:56:07 -0500
Subject: [PATCH 3/9] Integer stuff appears to be working

---
 au/BUILD.bazel                            |  17 +++
 au/code/au/apply_magnitude_test.cc        |  30 +++++
 au/code/au/quantity.hh                    |  75 +++++++++++
 au/code/au/quantity_test.cc               |  18 +++
 au/code/au/static_cast_checkers.hh        | 150 ++++++++++++++++++++++
 au/code/au/static_cast_checkers_test.cc   |  50 ++++++++
 fuzz/quantity_runtime_conversion_check.cc | 147 ++++++++++++++++++---
 7 files changed, 467 insertions(+), 20 deletions(-)
 create mode 100644 au/code/au/static_cast_checkers.hh
 create mode 100644 au/code/au/static_cast_checkers_test.cc

diff --git a/au/BUILD.bazel b/au/BUILD.bazel
index f5d34c47..1de03a23 100644
--- a/au/BUILD.bazel
+++ b/au/BUILD.bazel
@@ -471,6 +471,7 @@ cc_library(
         ":fwd",
         ":operators",
         ":rep",
+        ":static_cast_checkers",
         ":unit_of_measure",
         ":utility",
         ":zero",
@@ -545,6 +546,22 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "static_cast_checkers",
+    hdrs = ["code/au/static_cast_checkers.hh"],
+    includes = ["code"],
+)
+
+cc_test(
+    name = "static_cast_checkers_test",
+    size = "small",
+    srcs = ["code/au/static_cast_checkers_test.cc"],
+    deps = [
+        ":static_cast_checkers",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "stdx",
     srcs = glob([
diff --git a/au/code/au/apply_magnitude_test.cc b/au/code/au/apply_magnitude_test.cc
index b6aab045..60692ad3 100644
--- a/au/code/au/apply_magnitude_test.cc
+++ b/au/code/au/apply_magnitude_test.cc
@@ -152,6 +152,36 @@ TEST(ApplyMagnitude, MultipliesSingleNumberForIrrationalMagnitudeOnFloatingPoint
     EXPECT_THAT(apply_magnitude(2.0f, PI), SameTypeAndValue(2.0f * static_cast<float>(M_PI)));
 }
 
+TEST(WouldOverflow, AlwaysFalseForConversionFactorOfOne) {
+    {
+        using ApplyOneToI32 = ApplyMagnitudeT<int32_t, Magnitude<>>;
+
+        EXPECT_FALSE(ApplyOneToI32::would_overflow(2'147'483'647));
+        EXPECT_FALSE(ApplyOneToI32::would_overflow(1));
+        EXPECT_FALSE(ApplyOneToI32::would_overflow(0));
+        EXPECT_FALSE(ApplyOneToI32::would_overflow(-1));
+        EXPECT_FALSE(ApplyOneToI32::would_overflow(-2'147'483'648));
+    }
+
+    {
+        using ApplyOneToU8 = ApplyMagnitudeT<uint8_t, Magnitude<>>;
+
+        EXPECT_FALSE(ApplyOneToU8::would_overflow(255));
+        EXPECT_FALSE(ApplyOneToU8::would_overflow(1));
+        EXPECT_FALSE(ApplyOneToU8::would_overflow(0));
+    }
+
+    {
+        using ApplyOneToF = ApplyMagnitudeT<float, Magnitude<>>;
+
+        EXPECT_FALSE(ApplyOneToF::would_overflow(3.402e38f));
+        EXPECT_FALSE(ApplyOneToF::would_overflow(1.0f));
+        EXPECT_FALSE(ApplyOneToF::would_overflow(0.0f));
+        EXPECT_FALSE(ApplyOneToF::would_overflow(-1.0f));
+        EXPECT_FALSE(ApplyOneToF::would_overflow(-3.402e38f));
+    }
+}
+
 TEST(WouldOverflow, HasCorrectBoundariesForIntegerMultiply) {
     auto ONE_BILLION = pow<9>(mag<10>());
 
diff --git a/au/code/au/quantity.hh b/au/code/au/quantity.hh
index cb9c7866..e4f92bd7 100644
--- a/au/code/au/quantity.hh
+++ b/au/code/au/quantity.hh
@@ -21,6 +21,7 @@
 #include "au/fwd.hh"
 #include "au/operators.hh"
 #include "au/rep.hh"
+#include "au/static_cast_checkers.hh"
 #include "au/stdx/functional.hh"
 #include "au/unit_of_measure.hh"
 #include "au/utility/type_traits.hh"
@@ -28,6 +29,8 @@
 
 namespace au {
 
+struct Inches;
+
 //
 // Make a Quantity of the given Unit, which has this value as measured in the Unit.
 //
@@ -646,6 +649,54 @@ constexpr bool will_conversion_overflow(Quantity<U, R> q, TargetUnitSlot target_
         q.in(U{}));
 }
 
+template <typename... Ts>
+struct Typelist {};
+
+template <typename L1, typename L2>
+struct BlowUpIfMatch {
+    static void go() {}
+};
+template <typename... Ts, typename... Us>
+struct BlowUpIfMatch<Typelist<Ts...>, Typelist<Us...>> {
+    static void go() {
+        if (stdx::conjunction<std::is_same<Ts, Us>...>::value) {
+            std::terminate();
+        }
+    }
+};
+
+// Check conversion for overflow (new rep).
+template <typename TargetRep, typename U, typename R, typename TargetUnitSlot>
+constexpr bool will_conversion_overflow(Quantity<U, R> q, TargetUnitSlot target_unit) {
+    using BUI = BlowUpIfMatch<Typelist<U, R, TargetRep, TargetUnitSlot>,
+                              Typelist<Inches, uint8_t, int8_t, Inches>>;
+    // Someday, we would like a more efficient implementation --- one that simply computes, at
+    // compile time, the smallest value that would overflow, and then compares against that.
+    //
+    // This will at least let us get off the ground for now.
+    using Common = std::common_type_t<R, TargetRep>;
+    if (detail::will_static_cast_overflow<Common>(q.in(U{}))) {
+        // BUI::go();
+        return true;
+    }
+
+    const auto to_common = rep_cast<Common>(q);
+    if (will_conversion_overflow(to_common, target_unit)) {
+        // BUI::go();
+        return true;
+    }
+
+    const auto converted_but_not_narrowed = to_common.coerce_in(target_unit);
+    // return detail::will_static_cast_overflow<TargetRep>(converted_but_not_narrowed);
+    // ^
+    // ^ use this instead
+    const auto asdf = detail::will_static_cast_overflow<TargetRep>(converted_but_not_narrowed);
+    if (asdf) {
+        // BUI::go();
+    }
+    return asdf;
+}
+
 // Check conversion for truncation (no change of rep).
 template <typename U, typename R, typename TargetUnitSlot>
 constexpr bool will_conversion_truncate(Quantity<U, R> q, TargetUnitSlot target_unit) {
@@ -653,12 +704,36 @@ constexpr bool will_conversion_truncate(Quantity<U, R> q, TargetUnitSlot target_
         q.in(U{}));
 }
 
+// Check conversion for truncation (new rep).
+template <typename TargetRep, typename U, typename R, typename TargetUnitSlot>
+constexpr bool will_conversion_truncate(Quantity<U, R> q, TargetUnitSlot target_unit) {
+    using Common = std::common_type_t<R, TargetRep>;
+    if (detail::will_static_cast_truncate<Common>(q.in(U{}))) {
+        return true;
+    }
+
+    const auto to_common = rep_cast<Common>(q);
+    if (will_conversion_truncate(to_common, target_unit)) {
+        return true;
+    }
+
+    const auto converted_but_not_narrowed = to_common.coerce_in(target_unit);
+    return detail::will_static_cast_truncate<TargetRep>(converted_but_not_narrowed);
+}
+
 // Check for any lossiness in conversion (no change of rep).
 template <typename U, typename R, typename TargetUnitSlot>
 constexpr bool is_conversion_lossy(Quantity<U, R> q, TargetUnitSlot target_unit) {
     return will_conversion_truncate(q, target_unit) || will_conversion_overflow(q, target_unit);
 }
 
+// Check for any lossiness in conversion (new rep).
+template <typename TargetRep, typename U, typename R, typename TargetUnitSlot>
+constexpr bool is_conversion_lossy(Quantity<U, R> q, TargetUnitSlot target_unit) {
+    return will_conversion_truncate<TargetRep>(q, target_unit) ||
+           will_conversion_overflow<TargetRep>(q, target_unit);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Comparing and/or combining Quantities of different types.
 
diff --git a/au/code/au/quantity_test.cc b/au/code/au/quantity_test.cc
index 986c33c7..9ef56a01 100644
--- a/au/code/au/quantity_test.cc
+++ b/au/code/au/quantity_test.cc
@@ -852,6 +852,14 @@ TEST(WillConversionOverflow, SensitiveToTypeBoundariesForPureIntegerMultiply) {
     }
 }
 
+TEST(WillConversionOverflow, AlwaysFalseForQuantityEquivalentUnits) {
+    auto will_m_to_m_overflow = [](auto x) { return will_conversion_overflow(meters(x), meters); };
+
+    EXPECT_FALSE(will_m_to_m_overflow(2'147'483));
+    EXPECT_FALSE(will_m_to_m_overflow(-2'147'483));
+    EXPECT_FALSE(will_m_to_m_overflow(uint8_t{255}));
+}
+
 TEST(WillConversionTruncate, UsesModForIntegerTypes) {
     auto will_in_to_ft_truncate_i32 = [](int32_t x) {
         return will_conversion_truncate(inches(x), feet);
@@ -878,6 +886,16 @@ TEST(WillConversionTruncate, UsesModForIntegerTypes) {
     EXPECT_TRUE(will_in_to_ft_truncate_i32(-121));
 }
 
+TEST(WillConversionTruncate, AlwaysFalseForQuantityEquivalentUnits) {
+    auto will_in_to_in_truncate = [](auto x) {
+        return will_conversion_truncate(inches(x), inches);
+    };
+
+    EXPECT_FALSE(will_in_to_in_truncate(uint8_t{124}));
+    EXPECT_FALSE(will_in_to_in_truncate(0));
+    EXPECT_FALSE(will_in_to_in_truncate(-120));
+}
+
 TEST(IsConversionLossy, CorrectlyDiscriminatesBetweenLossyAndLosslessConversions) {
     // We will check literally every representable value in the type, and make sure that the result
     // of `is_conversion_lossy()` matches perfectly with the inability to recover the initial value.
diff --git a/au/code/au/static_cast_checkers.hh b/au/code/au/static_cast_checkers.hh
new file mode 100644
index 00000000..a50e6447
--- /dev/null
+++ b/au/code/au/static_cast_checkers.hh
@@ -0,0 +1,150 @@
+// Copyright 2024 Aurora Operations, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <exception>
+#include <limits>
+#include <type_traits>
+
+namespace au {
+
+struct Inches;
+
+namespace detail {
+
+template <typename Source, typename Dest>
+struct StaticCastChecker;
+
+template <typename Dest, typename Source>
+constexpr bool will_static_cast_overflow(Source x) {
+    return StaticCastChecker<Source, Dest>::will_static_cast_overflow(x);
+}
+
+template <typename Dest, typename Source>
+constexpr bool will_static_cast_truncate(Source x) {
+    return StaticCastChecker<Source, Dest>::will_static_cast_truncate(x);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Implementation details below.
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Overflow checking:
+
+// We should categorize the situation as the FIRST match: each category's implementation may assume
+// that no higher category is a match.
+enum class OverflowSituation {
+    DEST_IS_STRICT_SUPERSET,
+    UNSIGNED_TO_INTEGRAL,
+    SIGNED_TO_UNSIGNED,
+    SIGNED_TO_SIGNED,
+    UNEXPLORED,
+};
+
+template <typename Source, typename Dest>
+constexpr OverflowSituation categorize_overflow_situation() {
+    if (std::is_same<Source, Dest>::value) {
+        return OverflowSituation::DEST_IS_STRICT_SUPERSET;
+    }
+
+    if (std::is_integral<Source>::value && std::is_integral<Dest>::value) {
+        if ((std::is_signed<Source>::value == std::is_signed<Dest>::value) &&
+            (sizeof(Source) < sizeof(Dest))) {
+            return OverflowSituation::DEST_IS_STRICT_SUPERSET;
+        }
+
+        if (std::is_unsigned<Source>::value) {
+            return OverflowSituation::UNSIGNED_TO_INTEGRAL;
+        }
+
+        return std::is_unsigned<Dest>::value ? OverflowSituation::SIGNED_TO_UNSIGNED
+                                             : OverflowSituation::SIGNED_TO_SIGNED;
+    }
+
+    return OverflowSituation::UNEXPLORED;
+}
+
+template <typename Source, typename Dest, OverflowSituation Cat>
+struct StaticCastOverflowImpl {
+    static constexpr bool will_static_cast_overflow(Source x) { return true; }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::UNSIGNED_TO_INTEGRAL> {
+    static constexpr bool will_static_cast_overflow(Source x) {
+        return x > static_cast<Source>(std::numeric_limits<Dest>::max());
+    }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::SIGNED_TO_UNSIGNED> {
+    static constexpr bool will_static_cast_overflow(Source x) {
+        return (x < 0) ||
+               (static_cast<std::make_unsigned_t<Source>>(x) >
+                static_cast<std::make_unsigned_t<Source>>(std::numeric_limits<Dest>::max()));
+    }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::SIGNED_TO_SIGNED> {
+    static constexpr bool will_static_cast_overflow(Source x) {
+        return (x < static_cast<Source>(std::numeric_limits<Dest>::lowest())) ||
+               (x > static_cast<Source>(std::numeric_limits<Dest>::max()));
+    }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_IS_STRICT_SUPERSET> {
+    static constexpr bool will_static_cast_overflow(Source x) { return false; }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Truncation checking:
+
+enum class TruncationSituation {
+    INTEGRAL_TO_INTEGRAL,
+    UNEXPLORED,
+};
+
+template <typename Source, typename Dest>
+constexpr TruncationSituation categorize_truncation_situation() {
+    if (std::is_integral<Source>::value && std::is_integral<Dest>::value) {
+        return TruncationSituation::INTEGRAL_TO_INTEGRAL;
+    }
+
+    return TruncationSituation::UNEXPLORED;
+}
+
+template <typename Source, typename Dest, TruncationSituation Cat>
+struct StaticCastTruncateImpl {
+    static constexpr bool will_static_cast_truncate(Source x) { return true; }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::INTEGRAL_TO_INTEGRAL> {
+    static constexpr bool will_static_cast_truncate(Source) { return false; }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Main implementation:
+
+template <typename Source, typename Dest>
+struct StaticCastChecker
+    : StaticCastOverflowImpl<Source, Dest, categorize_overflow_situation<Source, Dest>()>,
+      StaticCastTruncateImpl<Source, Dest, categorize_truncation_situation<Source, Dest>()> {};
+
+}  // namespace detail
+}  // namespace au
diff --git a/au/code/au/static_cast_checkers_test.cc b/au/code/au/static_cast_checkers_test.cc
new file mode 100644
index 00000000..0471fc9f
--- /dev/null
+++ b/au/code/au/static_cast_checkers_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2024 Aurora Operations, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "au/static_cast_checkers.hh"
+
+#include "gtest/gtest.h"
+
+namespace au {
+namespace detail {
+
+TEST(WillStaticCastOverflow, DependsOnValueForUnsignedToNonContainingSigned) {
+    EXPECT_FALSE(will_static_cast_overflow<int8_t>(uint8_t{127}));
+    EXPECT_TRUE(will_static_cast_overflow<int8_t>(uint8_t{128}));
+}
+
+TEST(WillStaticCastOverflow, AlwaysFalseForUnsignedToContainingSigned) {
+    EXPECT_FALSE(will_static_cast_overflow<int>(uint8_t{124}));
+    EXPECT_FALSE(will_static_cast_overflow<int>(uint8_t{125}));
+}
+
+TEST(WillStaticCastOverflow, ChecksLimitForNonContainingSameSignedness) {
+    EXPECT_FALSE(will_static_cast_overflow<int8_t>(127));
+    EXPECT_TRUE(will_static_cast_overflow<int8_t>(128));
+}
+
+TEST(WillStaticCastOverflow, TrueForNegativeInputAndUnsignedDestination) {
+    EXPECT_TRUE(will_static_cast_overflow<uint8_t>(-1));
+    EXPECT_TRUE(will_static_cast_overflow<unsigned int>(int8_t{-1}));
+}
+
+TEST(WillStaticCastTruncate, AutomaticallyFalseForIntegralToIntegral) {
+    EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint8_t{127}));
+    EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint8_t{128}));
+    EXPECT_FALSE(will_static_cast_truncate<int8_t>(128));
+    EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint64_t{9876543210u}));
+}
+
+}  // namespace detail
+}  // namespace au
diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index f98d1786..d1856500 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -12,6 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <cxxabi.h>
+
+#include <string>
+
 #include "au/testing.hh"
 #include "au/units/inches.hh"
 #include "au/units/meters.hh"
@@ -21,6 +25,12 @@
 #include "gtest/gtest.h"
 
 namespace au {
+namespace detail {
+
+template <typename T>
+std::string type_name() {
+    return abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
+}
 
 template <typename T>
 struct Tag {};
@@ -74,40 +84,137 @@ struct ForEach<std::tuple<T, Ts...>> {
     }
 };
 
+enum class TestingScenarioCategory {
+    NOMINAL,
+    TRIVIAL,
+    IMPOSSIBLE,
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+constexpr TestingScenarioCategory categorize_testing_scenario() {
+    if (std::is_same<RepT, DestRepT>::value && std::is_same<UnitT, DestUnitT>::value) {
+        return TestingScenarioCategory::TRIVIAL;
+    }
+
+    using Common = std::common_type_t<RepT, DestRepT>;
+    constexpr auto conversion_factor = UnitRatioT<UnitT, DestUnitT>{};
+
+    if (is_integer(conversion_factor) &&
+        (get_value_result<Common>(conversion_factor).outcome != MagRepresentationOutcome::OK)) {
+        return TestingScenarioCategory::IMPOSSIBLE;
+    }
+
+    if (is_integer(mag<1>() / conversion_factor) &&
+        (get_value_result<Common>(mag<1>() / conversion_factor).outcome !=
+         MagRepresentationOutcome::OK)) {
+        return TestingScenarioCategory::IMPOSSIBLE;
+    }
+
+    return TestingScenarioCategory::NOMINAL;
+}
+
+template <typename RepT,
+          typename UnitT,
+          typename DestRepT,
+          typename DestUnitT,
+          TestingScenarioCategory Category>
+struct TestBodyImpl;
+
+template <bool R1Unsigned, bool R2Unsigned>
+struct SignFlipImpl;
+template <>
+struct SignFlipImpl<true, true> {
+    template <typename U1, typename R1, typename U2, typename R2>
+    static constexpr bool assess(const Quantity<U1, R1> &, const Quantity<U2, R2> &) {
+        return false;
+    }
+};
+template <>
+struct SignFlipImpl<true, false> {
+    template <typename U1, typename R1, typename U2, typename R2>
+    static constexpr bool assess(const Quantity<U1, R1> &, const Quantity<U2, R2> &b) {
+        return b < ZERO;
+    }
+};
+template <>
+struct SignFlipImpl<false, true> {
+    template <typename U1, typename R1, typename U2, typename R2>
+    static constexpr bool assess(const Quantity<U1, R1> &a, const Quantity<U2, R2> &) {
+        return a < ZERO;
+    }
+};
+template <>
+struct SignFlipImpl<false, false> {
+    template <typename U1, typename R1, typename U2, typename R2>
+    static constexpr bool assess(const Quantity<U1, R1> &a, const Quantity<U2, R2> &b) {
+        return (a < ZERO) != (b < ZERO);
+    }
+};
+template <typename U1, typename R1, typename U2, typename R2>
+constexpr bool sign_flip(const Quantity<U1, R1> &a, const Quantity<U2, R2> &b) {
+    return SignFlipImpl<std::is_unsigned<R1>::value, std::is_unsigned<R2>::value>::assess(a, b);
+}
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::NOMINAL> {
+    static constexpr void test(const Quantity<UnitT, RepT> &value) {
+        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
+
+        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
+        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
+        const bool flipped = sign_flip(value, destination);
+        const bool actual_loss = (value != round_trip) || flipped;
+
+        if (expect_loss != actual_loss) {
+            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
+                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
+                      << ")! " << std::endl
+                      << "Initial value: " << value << std::endl
+                      << "Round trip:    " << round_trip << std::endl
+                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
+                      << "Actual loss: " << (actual_loss ? "true" : "false")
+                      << (((round_trip == value) && flipped) ? " (sign flipped)" : "") << std::endl;
+            std::terminate();
+        }
+    }
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::TRIVIAL> {
+    static constexpr void test(const Quantity<UnitT, RepT> &) {}
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::IMPOSSIBLE> {
+    static constexpr void test(const Quantity<UnitT, RepT> &) {}
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBody : TestBodyImpl<RepT,
+                               UnitT,
+                               DestRepT,
+                               DestUnitT,
+                               categorize_testing_scenario<RepT, UnitT, DestRepT, DestUnitT>()> {};
+
 TEST(RuntimeConversionCheckers, Fuzz) {
     GeneratorFor<IntTypes> generators{9876543210u};
     constexpr auto for_each_params = ForEach<CartesianProduct<std::tuple, IntTypes, Units>>{};
     for (auto i = 0u; i < 100'000u; ++i) {
         for_each_params([&](auto source_params) {
-            using IntT = decltype(type_of(std::get<0>(source_params)));
+            using RepT = decltype(type_of(std::get<0>(source_params)));
             using UnitT = decltype(type_of(std::get<1>(source_params)));
 
-            const auto value = make_quantity<UnitT>(generators.template next_value<IntT>());
+            const auto value = make_quantity<UnitT>(generators.template next_value<RepT>());
 
             for_each_params([&](auto dest_params) {
-                using DestIntT = decltype(type_of(std::get<0>(dest_params)));
+                using DestRepT = decltype(type_of(std::get<0>(dest_params)));
                 using DestUnitT = decltype(type_of(std::get<1>(dest_params)));
 
-                if (source_params == dest_params) {
-                    return;
-                }
-
-                const bool expect_loss = is_conversion_lossy<DestIntT>(value, DestUnitT{});
-
-                const auto round_trip = value.template coerce_as<DestIntT>(DestUnitT{})
-                                            .template coerce_as<IntT>(UnitT{});
-                const bool actual_loss = (value != round_trip);
-
-                if (expect_loss != actual_loss) {
-                    std::cout << "Error found for <" << typeid(IntT).name() << ">("
-                              << unit_label(UnitT{}) << ") -> <" << typeid(DestIntT).name() << ">("
-                              << unit_label(DestUnitT{}) << ")! "
-                              << "Value: " << value << " Round trip: " << round_trip << std::endl;
-                    std::terminate();
-                }
+                ::au::detail::TestBody<RepT, UnitT, DestRepT, DestUnitT>::test(value);
             });
         });
     }
 }
 
+}  // namespace detail
 }  // namespace au

From d5e6c99669d0b25001d29fcb4ae79c62469148c2 Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 10:34:36 -0500
Subject: [PATCH 4/9] Add floating point support

---
 fuzz/quantity_runtime_conversion_check.cc    | 106 +++++++++++++++++--
 fuzz/quantity_runtime_conversion_checkers.hh |  46 +++++++-
 2 files changed, 144 insertions(+), 8 deletions(-)

diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index d1856500..86bf5dd4 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -57,7 +57,7 @@ using List = typename ListImpl<Ts...>::type;
 template <typename... Ts>
 struct ListImpl : stdx::type_identity<std::tuple<Tag<Ts>...>> {};
 
-using IntTypes = List<uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t>;
+using Reps = List<uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t, float>;
 using Units = List<Inches, Meters, Miles, Yards>;
 
 template <typename PackT>
@@ -85,9 +85,13 @@ struct ForEach<std::tuple<T, Ts...>> {
 };
 
 enum class TestingScenarioCategory {
-    NOMINAL,
+    INTEGRAL_TO_INTEGRAL,
+    INTEGRAL_TO_FLOAT,
+    FLOAT_TO_INTEGRAL,
+    FLOAT_TO_FLOAT,
     TRIVIAL,
     IMPOSSIBLE,
+    UNSUPPORTED,
 };
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
@@ -110,7 +114,17 @@ constexpr TestingScenarioCategory categorize_testing_scenario() {
         return TestingScenarioCategory::IMPOSSIBLE;
     }
 
-    return TestingScenarioCategory::NOMINAL;
+    static_assert(std::is_integral<RepT>::value || std::is_floating_point<RepT>::value, "");
+    static_assert(std::is_integral<DestRepT>::value || std::is_floating_point<DestRepT>::value, "");
+    if (std::is_integral<RepT>::value) {
+        return std::is_integral<DestRepT>::value ? TestingScenarioCategory::INTEGRAL_TO_INTEGRAL
+                                                 : TestingScenarioCategory::INTEGRAL_TO_FLOAT;
+    } else {
+        return std::is_integral<DestRepT>::value ? TestingScenarioCategory::FLOAT_TO_INTEGRAL
+                                                 : TestingScenarioCategory::FLOAT_TO_FLOAT;
+    }
+
+    return TestingScenarioCategory::UNSUPPORTED;
 }
 
 template <typename RepT,
@@ -156,7 +170,11 @@ constexpr bool sign_flip(const Quantity<U1, R1> &a, const Quantity<U2, R2> &b) {
 }
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::NOMINAL> {
+struct TestBodyImpl<RepT,
+                    UnitT,
+                    DestRepT,
+                    DestUnitT,
+                    TestingScenarioCategory::INTEGRAL_TO_INTEGRAL> {
     static constexpr void test(const Quantity<UnitT, RepT> &value) {
         const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
 
@@ -179,6 +197,82 @@ struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::N
     }
 };
 
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::INTEGRAL_TO_FLOAT> {
+    static constexpr void test(const Quantity<UnitT, RepT> &value) {
+        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
+
+        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
+        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
+
+        const bool actual_loss = (value != round_trip);
+        if (expect_loss != actual_loss) {
+            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
+                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
+                      << ")! " << std::endl
+                      << "Initial value: " << value << std::endl
+                      << "Round trip:    " << round_trip << std::endl
+                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
+                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl;
+            std::terminate();
+        }
+    }
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::FLOAT_TO_FLOAT> {
+    static constexpr void test(const Quantity<UnitT, RepT> &value) {
+        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
+
+        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
+        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
+
+        const RepT val_as_dest = static_cast<DestRepT>(value.in(UnitT{}));
+        using src_lim = std::numeric_limits<RepT>;
+        using dest_lim = std::numeric_limits<DestRepT>;
+        const auto min_ok = make_quantity<UnitT>(std::nextafter(
+            static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::lowest())), src_lim::lowest()));
+        const auto max_ok = make_quantity<UnitT>(std::nextafter(
+            static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::max())), src_lim::max()));
+
+        const bool actual_loss = (round_trip < min_ok) || (round_trip > max_ok);
+        if (expect_loss != actual_loss) {
+            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
+                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
+                      << ")! " << std::endl
+                      << "Initial value: " << value << std::endl
+                      << "Round trip:    " << round_trip << std::endl
+                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
+                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl
+                      << "Min OK: " << min_ok << std::endl
+                      << "Max OK: " << max_ok << std::endl;
+            std::terminate();
+        }
+    }
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::FLOAT_TO_INTEGRAL> {
+    static constexpr void test(const Quantity<UnitT, RepT> &value) {
+        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
+
+        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
+        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
+
+        const bool actual_loss = (value != round_trip);
+        if (expect_loss != actual_loss) {
+            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
+                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
+                      << ")! " << std::endl
+                      << "Initial value: " << value << std::endl
+                      << "Round trip:    " << round_trip << std::endl
+                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
+                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl;
+            std::terminate();
+        }
+    }
+};
+
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
 struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::TRIVIAL> {
     static constexpr void test(const Quantity<UnitT, RepT> &) {}
@@ -197,8 +291,8 @@ struct TestBody : TestBodyImpl<RepT,
                                categorize_testing_scenario<RepT, UnitT, DestRepT, DestUnitT>()> {};
 
 TEST(RuntimeConversionCheckers, Fuzz) {
-    GeneratorFor<IntTypes> generators{9876543210u};
-    constexpr auto for_each_params = ForEach<CartesianProduct<std::tuple, IntTypes, Units>>{};
+    GeneratorFor<Reps> generators{9876543210u};
+    constexpr auto for_each_params = ForEach<CartesianProduct<std::tuple, Reps, Units>>{};
     for (auto i = 0u; i < 100'000u; ++i) {
         for_each_params([&](auto source_params) {
             using RepT = decltype(type_of(std::get<0>(source_params)));
diff --git a/fuzz/quantity_runtime_conversion_checkers.hh b/fuzz/quantity_runtime_conversion_checkers.hh
index b736dc20..ef66e26e 100644
--- a/fuzz/quantity_runtime_conversion_checkers.hh
+++ b/fuzz/quantity_runtime_conversion_checkers.hh
@@ -22,14 +22,56 @@
 
 namespace au {
 
+enum class GeneratorStrategy {
+    INTEGRAL,
+    FLOAT,
+    UNSUPPORTED,
+};
+
+template <typename T>
+constexpr GeneratorStrategy get_generator_strategy() {
+    if (std::is_integral<T>::value) {
+        return GeneratorStrategy::INTEGRAL;
+    }
+    if (std::is_floating_point<T>::value) {
+        return GeneratorStrategy::FLOAT;
+    }
+    return GeneratorStrategy::UNSUPPORTED;
+}
+
+template <typename T, GeneratorStrategy Strategy>
+struct RandomValueGeneratorImpl;
+
+template <typename T>
+struct RandomValueGeneratorImpl<T, GeneratorStrategy::INTEGRAL> {
+    T next_value(std::mt19937_64 &engine) {
+        static std::uniform_int_distribution<std::uint64_t> uniform{};
+        return static_cast<T>(uniform(engine));
+    }
+};
+
+template <typename T>
+struct RandomValueGeneratorImpl<T, GeneratorStrategy::FLOAT> {
+    T next_value(std::mt19937_64 &engine) {
+        static std::uniform_int_distribution<std::uint8_t> uniform{};
+        std::uint8_t bytes[sizeof(T)];
+        for (auto i = 0u; i < sizeof(T); ++i) {
+            bytes[i] = uniform(engine);
+        }
+
+        T result{};
+        memcpy(&result, bytes, sizeof(T));
+        return result;
+    }
+};
+
 template <typename T>
 class RandomValueGenerator {
  public:
     RandomValueGenerator(std::uint64_t seed) : engine_{seed} {}
 
     T next_value() {
-        static std::uniform_int_distribution<std::uint64_t> uniform{};
-        return static_cast<T>(uniform(engine_));
+        return RandomValueGeneratorImpl<T, get_generator_strategy<T>()>{}.next_value(engine_);
     }
 
  private:

From 6e147c63843c7678637ecd3f14d9cfbd7617a690 Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 10:54:36 -0500
Subject: [PATCH 5/9] Refactor: reduce duplication

---
 fuzz/quantity_runtime_conversion_check.cc | 156 ++++++++++------------
 1 file changed, 72 insertions(+), 84 deletions(-)

diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index 86bf5dd4..92128aae 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -84,7 +84,7 @@ struct ForEach<std::tuple<T, Ts...>> {
     }
 };
 
-enum class TestingScenarioCategory {
+enum class TestCategory {
     INTEGRAL_TO_INTEGRAL,
     INTEGRAL_TO_FLOAT,
     FLOAT_TO_INTEGRAL,
@@ -95,9 +95,9 @@ enum class TestingScenarioCategory {
 };
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-constexpr TestingScenarioCategory categorize_testing_scenario() {
+constexpr TestCategory categorize_testing_scenario() {
     if (std::is_same<RepT, DestRepT>::value && std::is_same<UnitT, DestUnitT>::value) {
-        return TestingScenarioCategory::TRIVIAL;
+        return TestCategory::TRIVIAL;
     }
 
     using Common = std::common_type_t<RepT, DestRepT>;
@@ -105,33 +105,33 @@ constexpr TestingScenarioCategory categorize_testing_scenario() {
 
     if (is_integer(conversion_factor) &&
         (get_value_result<Common>(conversion_factor).outcome != MagRepresentationOutcome::OK)) {
-        return TestingScenarioCategory::IMPOSSIBLE;
+        return TestCategory::IMPOSSIBLE;
     }
 
     if (is_integer(mag<1>() / conversion_factor) &&
         (get_value_result<Common>(mag<1>() / conversion_factor).outcome !=
          MagRepresentationOutcome::OK)) {
-        return TestingScenarioCategory::IMPOSSIBLE;
+        return TestCategory::IMPOSSIBLE;
     }
 
     static_assert(std::is_integral<RepT>::value || std::is_floating_point<RepT>::value, "");
     static_assert(std::is_integral<DestRepT>::value || std::is_floating_point<DestRepT>::value, "");
     if (std::is_integral<RepT>::value) {
-        return std::is_integral<DestRepT>::value ? TestingScenarioCategory::INTEGRAL_TO_INTEGRAL
-                                                 : TestingScenarioCategory::INTEGRAL_TO_FLOAT;
+        return std::is_integral<DestRepT>::value ? TestCategory::INTEGRAL_TO_INTEGRAL
+                                                 : TestCategory::INTEGRAL_TO_FLOAT;
     } else {
-        return std::is_integral<DestRepT>::value ? TestingScenarioCategory::FLOAT_TO_INTEGRAL
-                                                 : TestingScenarioCategory::FLOAT_TO_FLOAT;
+        return std::is_integral<DestRepT>::value ? TestCategory::FLOAT_TO_INTEGRAL
+                                                 : TestCategory::FLOAT_TO_FLOAT;
     }
 
-    return TestingScenarioCategory::UNSUPPORTED;
+    return TestCategory::UNSUPPORTED;
 }
 
 template <typename RepT,
           typename UnitT,
           typename DestRepT,
           typename DestUnitT,
-          TestingScenarioCategory Category>
+          TestCategory Category>
 struct TestBodyImpl;
 
 template <bool R1Unsigned, bool R2Unsigned>
@@ -169,97 +169,65 @@ constexpr bool sign_flip(const Quantity<U1, R1> &a, const Quantity<U2, R2> &b) {
     return SignFlipImpl<std::is_unsigned<R1>::value, std::is_unsigned<R2>::value>::assess(a, b);
 }
 
-template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT,
-                    UnitT,
-                    DestRepT,
-                    DestUnitT,
-                    TestingScenarioCategory::INTEGRAL_TO_INTEGRAL> {
-    static constexpr void test(const Quantity<UnitT, RepT> &value) {
-        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
-
-        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
-        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
-        const bool flipped = sign_flip(value, destination);
-        const bool actual_loss = (value != round_trip) || flipped;
+struct LossCheck {
+    bool is_lossy;
+    std::string comment = "";
+};
 
-        if (expect_loss != actual_loss) {
-            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
-                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
-                      << ")! " << std::endl
-                      << "Initial value: " << value << std::endl
-                      << "Round trip:    " << round_trip << std::endl
-                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
-                      << "Actual loss: " << (actual_loss ? "true" : "false")
-                      << (((round_trip == value) && flipped) ? " (sign flipped)" : "") << std::endl;
-            std::terminate();
-        }
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT, TestCategory Cat>
+struct LossChecker {
+    static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
+                                    const Quantity<DestUnitT, DestRepT> &,
+                                    const Quantity<UnitT, RepT> &round_trip) {
+        // Default implementation.
+        const bool actual_loss = (value != round_trip);
+        return {actual_loss};
     }
 };
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::INTEGRAL_TO_FLOAT> {
-    static constexpr void test(const Quantity<UnitT, RepT> &value) {
-        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
-
-        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
-        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
-
-        const bool actual_loss = (value != round_trip);
-        if (expect_loss != actual_loss) {
-            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
-                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
-                      << ")! " << std::endl
-                      << "Initial value: " << value << std::endl
-                      << "Round trip:    " << round_trip << std::endl
-                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
-                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl;
-            std::terminate();
-        }
+struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_INTEGRAL> {
+    static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
+                                    const Quantity<DestUnitT, DestRepT> &destination,
+                                    const Quantity<UnitT, RepT> &round_trip) {
+        const bool flipped = sign_flip(value, destination);
+        const bool actual_loss = (value != round_trip) || flipped;
+        return {actual_loss, flipped ? "Sign flipped" : ""};
     }
 };
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::FLOAT_TO_FLOAT> {
-    static constexpr void test(const Quantity<UnitT, RepT> &value) {
-        const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
-
-        const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
-        const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
-
-        const RepT val_as_dest = static_cast<DestRepT>(value.in(UnitT{}));
+struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_FLOAT> {
+    static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
+                                    const Quantity<DestUnitT, DestRepT> &,
+                                    const Quantity<UnitT, RepT> &round_trip) {
         using src_lim = std::numeric_limits<RepT>;
         using dest_lim = std::numeric_limits<DestRepT>;
+
+        const RepT val_as_dest = static_cast<DestRepT>(value.in(UnitT{}));
         const auto min_ok = make_quantity<UnitT>(std::nextafter(
             static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::lowest())), src_lim::lowest()));
         const auto max_ok = make_quantity<UnitT>(std::nextafter(
             static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::max())), src_lim::max()));
 
         const bool actual_loss = (round_trip < min_ok) || (round_trip > max_ok);
-        if (expect_loss != actual_loss) {
-            std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
-                      << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
-                      << ")! " << std::endl
-                      << "Initial value: " << value << std::endl
-                      << "Round trip:    " << round_trip << std::endl
-                      << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
-                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl
-                      << "Min OK: " << min_ok << std::endl
-                      << "Max OK: " << max_ok << std::endl;
-            std::terminate();
-        }
+        return {actual_loss};
     }
 };
 
-template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::FLOAT_TO_INTEGRAL> {
-    static constexpr void test(const Quantity<UnitT, RepT> &value) {
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT, TestCategory Cat>
+struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat> {
+    using LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>::check_for_loss;
+
+    static void test(const Quantity<UnitT, RepT> &value) {
         const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
 
         const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
         const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
 
-        const bool actual_loss = (value != round_trip);
+        const auto loss_check = check_for_loss(value, destination, round_trip);
+        const bool actual_loss = loss_check.is_lossy;
+
         if (expect_loss != actual_loss) {
             std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
                       << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
@@ -267,21 +235,41 @@ struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::F
                       << "Initial value: " << value << std::endl
                       << "Round trip:    " << round_trip << std::endl
                       << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
-                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl;
+                      << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl
+                      << "Extra comments: " << loss_check.comment << std::endl;
             std::terminate();
         }
     }
 };
 
-template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::TRIVIAL> {
-    static constexpr void test(const Quantity<UnitT, RepT> &) {}
+template <typename U, typename R>
+struct NoOpTestImpl {
+    static void test(const Quantity<U, R> &) {}
 };
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
-struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestingScenarioCategory::IMPOSSIBLE> {
-    static constexpr void test(const Quantity<UnitT, RepT> &) {}
-};
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_INTEGRAL>
+    : NominalTestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_INTEGRAL> {};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_FLOAT>
+    : NominalTestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_FLOAT> {};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_FLOAT>
+    : NominalTestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_FLOAT> {};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_INTEGRAL>
+    : NominalTestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_INTEGRAL> {};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::TRIVIAL>
+    : NoOpTestImpl<UnitT, RepT> {};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct TestBodyImpl<RepT, UnitT, DestRepT, DestUnitT, TestCategory::IMPOSSIBLE>
+    : NoOpTestImpl<UnitT, RepT> {};
 
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
 struct TestBody : TestBodyImpl<RepT,

From 56dc153eb40e86560220fa0e6d2e2a5f29a5f08e Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 13:16:27 -0500
Subject: [PATCH 6/9] Add some support for int-to-float

---
 au/code/au/static_cast_checkers.hh            | 67 ++++++++++++++++---
 au/code/au/static_cast_checkers_test.cc       | 28 ++++++++
 fuzz/quantity_runtime_conversion_check.cc     | 28 ++++++--
 fuzz/quantity_runtime_conversion_checkers.hh  |  7 ++
 ...antity_runtime_conversion_checkers_test.cc | 49 ++++++++++++++
 5 files changed, 164 insertions(+), 15 deletions(-)

diff --git a/au/code/au/static_cast_checkers.hh b/au/code/au/static_cast_checkers.hh
index a50e6447..9222ec63 100644
--- a/au/code/au/static_cast_checkers.hh
+++ b/au/code/au/static_cast_checkers.hh
@@ -47,7 +47,7 @@ constexpr bool will_static_cast_truncate(Source x) {
 // We should categorize the situation as the FIRST match: each category's implementation may assume
 // that no higher category is a match.
 enum class OverflowSituation {
-    DEST_IS_STRICT_SUPERSET,
+    DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS,
     UNSIGNED_TO_INTEGRAL,
     SIGNED_TO_UNSIGNED,
     SIGNED_TO_SIGNED,
@@ -56,14 +56,27 @@ enum class OverflowSituation {
 
 template <typename Source, typename Dest>
 constexpr OverflowSituation categorize_overflow_situation() {
+    static_assert(std::is_arithmetic<Source>::value && std::is_arithmetic<Dest>::value,
+                  "Only arithmetic types are supported so far.");
+
     if (std::is_same<Source, Dest>::value) {
-        return OverflowSituation::DEST_IS_STRICT_SUPERSET;
+        return OverflowSituation::DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS;
+    }
+
+    if (std::is_integral<Source>::value && std::is_floating_point<Dest>::value) {
+        // Dest should always fully contain Source, but we'll double check to make sure.
+        return ((static_cast<long double>(std::numeric_limits<Dest>::max()) >=
+                 static_cast<long double>(std::numeric_limits<Source>::max())) &&
+                static_cast<long double>(std::numeric_limits<Dest>::lowest()) <=
+                    static_cast<long double>(std::numeric_limits<Source>::lowest()))
+                   ? OverflowSituation::DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS
+                   : OverflowSituation::UNEXPLORED;
     }
 
     if (std::is_integral<Source>::value && std::is_integral<Dest>::value) {
         if ((std::is_signed<Source>::value == std::is_signed<Dest>::value) &&
             (sizeof(Source) < sizeof(Dest))) {
-            return OverflowSituation::DEST_IS_STRICT_SUPERSET;
+            return OverflowSituation::DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS;
         }
 
         if (std::is_unsigned<Source>::value) {
@@ -107,7 +120,7 @@ struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::SIGNED_TO_SIGNED>
 };
 
 template <typename Source, typename Dest>
-struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_IS_STRICT_SUPERSET> {
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS> {
     static constexpr bool will_static_cast_overflow(Source x) { return false; }
 };
 
@@ -115,14 +128,32 @@ struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_IS_STRICT_SU
 // Truncation checking:
 
 enum class TruncationSituation {
-    INTEGRAL_TO_INTEGRAL,
+    CANNOT_TRUNCATE,
+    UNSIGNED_TO_FLOAT,
+    SIGNED_TO_FLOAT,
     UNEXPLORED,
 };
 
 template <typename Source, typename Dest>
 constexpr TruncationSituation categorize_truncation_situation() {
-    if (std::is_integral<Source>::value && std::is_integral<Dest>::value) {
-        return TruncationSituation::INTEGRAL_TO_INTEGRAL;
+    static_assert(std::is_arithmetic<Source>::value && std::is_arithmetic<Dest>::value,
+                  "Only arithmetic types are supported so far.");
+
+    if (std::is_same<Source, Dest>::value) {
+        return TruncationSituation::CANNOT_TRUNCATE;
+    }
+
+    if (std::is_integral<Source>::value) {
+        if (std::is_integral<Dest>::value) {
+            return TruncationSituation::CANNOT_TRUNCATE;
+        }
+
+        static_assert(std::numeric_limits<Dest>::radix == std::numeric_limits<Source>::radix,
+                      "No attempt yet to support mixed-radix");
+        return (std::numeric_limits<Dest>::digits >= std::numeric_limits<Source>::digits)
+                   ? TruncationSituation::CANNOT_TRUNCATE
+                   : (std::is_unsigned<Source>::value ? TruncationSituation::UNSIGNED_TO_FLOAT
+                                                      : TruncationSituation::SIGNED_TO_FLOAT);
     }
 
     return TruncationSituation::UNEXPLORED;
@@ -134,10 +165,30 @@ struct StaticCastTruncateImpl {
 };
 
 template <typename Source, typename Dest>
-struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::INTEGRAL_TO_INTEGRAL> {
+struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::CANNOT_TRUNCATE> {
     static constexpr bool will_static_cast_truncate(Source) { return false; }
 };
 
+template <typename Source, typename Dest>
+struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::UNSIGNED_TO_FLOAT> {
+    static constexpr bool will_static_cast_truncate(Source x) {
+        constexpr auto MIN_NON_REPRESENTABLE_VAL =
+            (Source{1u} << std::numeric_limits<Dest>::digits) + 1u;
+        return (x >= MIN_NON_REPRESENTABLE_VAL) && (static_cast<Source>(static_cast<Dest>(x)) != x);
+    }
+};
+
+template <typename Source, typename Dest>
+struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::SIGNED_TO_FLOAT> {
+    static constexpr bool will_static_cast_truncate(Source x) {
+        constexpr auto MIN_POS_NON_REPRESENTABLE_VAL =
+            (Source{1} << (std::numeric_limits<Dest>::digits - 1)) + 1;
+        constexpr auto MAX_NEG_NON_REPRESENTABLE_VAL = -MIN_POS_NON_REPRESENTABLE_VAL;
+        return (x >= MIN_POS_NON_REPRESENTABLE_VAL || x <= MAX_NEG_NON_REPRESENTABLE_VAL) &&
+               (static_cast<Source>(static_cast<Dest>(x)) != x);
+    }
+};
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Main implementation:
 
diff --git a/au/code/au/static_cast_checkers_test.cc b/au/code/au/static_cast_checkers_test.cc
index 0471fc9f..58f792c4 100644
--- a/au/code/au/static_cast_checkers_test.cc
+++ b/au/code/au/static_cast_checkers_test.cc
@@ -39,6 +39,34 @@ TEST(WillStaticCastOverflow, TrueForNegativeInputAndUnsignedDestination) {
     EXPECT_TRUE(will_static_cast_overflow<unsigned int>(int8_t{-1}));
 }
 
+TEST(WillStaticCastOverflow, FalseWhenDestBoundsContainsSourceBounds) {
+    EXPECT_FALSE(will_static_cast_overflow<float>(std::numeric_limits<uint64_t>::max()));
+}
+
+TEST(WillStaticCastTruncate, IntToFloatFalseForIntTypeThatCanFitInFloat) {
+    EXPECT_FALSE(will_static_cast_truncate<float>(uint8_t{124}));
+    EXPECT_FALSE(will_static_cast_truncate<double>(124));
+
+    static_assert(std::numeric_limits<double>::digits >= std::numeric_limits<int32_t>::digits, "");
+    EXPECT_FALSE(will_static_cast_truncate<double>(std::numeric_limits<int32_t>::max()));
+    EXPECT_FALSE(will_static_cast_truncate<double>(std::numeric_limits<int32_t>::max() - 1));
+
+    static_assert(std::numeric_limits<double>::digits >= std::numeric_limits<uint32_t>::digits, "");
+    EXPECT_FALSE(will_static_cast_truncate<double>(std::numeric_limits<uint32_t>::max()));
+    EXPECT_FALSE(will_static_cast_truncate<double>(std::numeric_limits<uint32_t>::max() - 1));
+}
+
+TEST(WillStaticCastTruncate, IntToFloatDependsOnValueInGeneral) {
+    static_assert(std::numeric_limits<float>::radix == 2, "Test assumes binary");
+
+    constexpr auto first_unrepresentable = (1 << std::numeric_limits<float>::digits) + 1;
+    EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable - 2));
+    EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable - 1));
+    EXPECT_TRUE(will_static_cast_truncate<float>(first_unrepresentable + 0));
+    EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable + 1));
+    EXPECT_TRUE(will_static_cast_truncate<float>(first_unrepresentable + 2));
+}
+
 TEST(WillStaticCastTruncate, AutomaticallyFalseForIntegralToIntegral) {
     EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint8_t{127}));
     EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint8_t{128}));
diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index 92128aae..2d607c5a 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <cxxabi.h>
-
+#include <cmath>
+#include <limits>
 #include <string>
 
 #include "au/testing.hh"
@@ -27,11 +27,6 @@
 namespace au {
 namespace detail {
 
-template <typename T>
-std::string type_name() {
-    return abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
-}
-
 template <typename T>
 struct Tag {};
 
@@ -215,6 +210,25 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_FLOA
     }
 };
 
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_FLOAT> {
+    static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
+                                    const Quantity<DestUnitT, DestRepT> &destination,
+                                    const Quantity<UnitT, RepT> &round_trip) {
+        if (round_trip == value) {
+            return {false};
+        }
+
+        const auto next_destination = make_quantity<DestUnitT>(
+            std::nextafter(destination.in(DestUnitT{}), std::numeric_limits<DestRepT>::infinity()));
+        if (next_destination.template coerce_as<RepT>(UnitT{}) == value) {
+            return {false, "Within expected floating point error"};
+        }
+
+        return {true};
+    }
+};
+
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT, TestCategory Cat>
 struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat> {
     using LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>::check_for_loss;
diff --git a/fuzz/quantity_runtime_conversion_checkers.hh b/fuzz/quantity_runtime_conversion_checkers.hh
index ef66e26e..8add88a6 100644
--- a/fuzz/quantity_runtime_conversion_checkers.hh
+++ b/fuzz/quantity_runtime_conversion_checkers.hh
@@ -14,6 +14,8 @@
 
 #pragma once
 
+#include <cxxabi.h>
+
 #include <cstdint>
 #include <random>
 
@@ -22,6 +24,11 @@
 
 namespace au {
 
+template <typename T>
+std::string type_name() {
+    return abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
+}
+
 enum class GeneratorStrategy {
     INTEGRAL,
     FLOAT,
diff --git a/fuzz/quantity_runtime_conversion_checkers_test.cc b/fuzz/quantity_runtime_conversion_checkers_test.cc
index ab0b3885..1a47a851 100644
--- a/fuzz/quantity_runtime_conversion_checkers_test.cc
+++ b/fuzz/quantity_runtime_conversion_checkers_test.cc
@@ -82,6 +82,55 @@ TEST(CartesianProduct, CanHandleMultipleLayers) {
                                         std::tuple<A_2, B_2, C_2>>>();
 }
 
+template <typename T, typename U, typename R>
+std::string will_truncate(Quantity<U, R> q) {
+    return detail::will_static_cast_truncate<T>(q.in(U{})) ? "true" : "false";
+}
+
+template <typename T, typename U, typename R>
+std::string will_overflow(Quantity<U, R> q) {
+    return detail::will_static_cast_overflow<T>(q.in(U{})) ? "true" : "false";
+}
+
+template <typename TargetR, typename U, typename R, typename TargetUnitSlot>
+void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
+    // Set max floating point precision.
+    std::cout.precision(std::numeric_limits<long double>::digits10);
+
+    using TargetUnit = AssociatedUnitT<TargetUnitSlot>;
+    using Common = std::common_type_t<R, TargetR>;
+    std::cout << "Initial value:  " << q << " (rep: " << type_name<R>() << ")\n";
+    std::cout << "Common type:    " << type_name<Common>() << "\n";
+    std::cout << "  expect trunc: " << will_truncate<Common>(q) << "\n";
+    std::cout << "  expect overf: " << will_overflow<Common>(q) << "\n";
+    std::cout << "Val as common:  " << static_cast<Common>(q.in(U{})) << " (" << type_name<Common>()
+              << ")\n";
+
+    const auto intermediate = q.template as<Common>(TargetUnit{});
+
+    std::cout << "\nConvert to target" << std::endl;
+    std::cout << "As common rep : " << intermediate << "\n";
+
+    const auto destination = q.template as<TargetR>(TargetUnit{});
+    std::cout << "As target rep : " << destination << "\n";
+    std::cout << "  expect trunc: " << will_truncate<Common>(destination) << "\n";
+    std::cout << "  expect overf: " << will_overflow<Common>(destination) << "\n";
+
+    std::cout << "Back to common: " << static_cast<Common>(destination.in(TargetUnit{})) << " ("
+              << type_name<Common>() << ")\n";
+
+    const auto intermediate_back = destination.template as<Common>(U{});
+
+    std::cout << "\nConvert back to initial unit" << std::endl;
+    std::cout << "As common rep : " << intermediate_back << "\n";
+
+    const auto round_trip = destination.template as<R>(U{});
+    std::cout << "As initial rep: " << round_trip << "\n";
+
+    std::cout.flush();
+    std::terminate();
+}
+
 template <typename T>
 class QuantityRuntimeConversionChecker : public ::testing::Test {};
 

From 629b3c9a09f6819fde693cc4d63b79843330257b Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 13:43:21 -0500
Subject: [PATCH 7/9] Handle first float-to-int

---
 au/code/au/static_cast_checkers.hh            | 26 +++++++++
 au/code/au/static_cast_checkers_test.cc       | 34 ++++++++++++
 fuzz/quantity_runtime_conversion_check.cc     | 54 +++++++++++++++++--
 ...antity_runtime_conversion_checkers_test.cc |  2 +
 4 files changed, 111 insertions(+), 5 deletions(-)

diff --git a/au/code/au/static_cast_checkers.hh b/au/code/au/static_cast_checkers.hh
index 9222ec63..83ea1246 100644
--- a/au/code/au/static_cast_checkers.hh
+++ b/au/code/au/static_cast_checkers.hh
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <exception>
 #include <limits>
 #include <type_traits>
@@ -51,6 +52,7 @@ enum class OverflowSituation {
     UNSIGNED_TO_INTEGRAL,
     SIGNED_TO_UNSIGNED,
     SIGNED_TO_SIGNED,
+    FLOAT_TO_INTEGRAL,
     UNEXPLORED,
 };
 
@@ -87,6 +89,10 @@ constexpr OverflowSituation categorize_overflow_situation() {
                                              : OverflowSituation::SIGNED_TO_SIGNED;
     }
 
+    if (std::is_floating_point<Source>::value && std::is_integral<Dest>::value) {
+        return OverflowSituation::FLOAT_TO_INTEGRAL;
+    }
+
     return OverflowSituation::UNEXPLORED;
 }
 
@@ -119,6 +125,14 @@ struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::SIGNED_TO_SIGNED>
     }
 };
 
+template <typename Source, typename Dest>
+struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::FLOAT_TO_INTEGRAL> {
+    static constexpr bool will_static_cast_overflow(Source x) {
+        return (x < static_cast<Source>(std::numeric_limits<Dest>::lowest())) ||
+               (x > static_cast<Source>(std::numeric_limits<Dest>::max()));
+    }
+};
+
 template <typename Source, typename Dest>
 struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_BOUNDS_CONTAIN_SOURCE_BOUNDS> {
     static constexpr bool will_static_cast_overflow(Source x) { return false; }
@@ -131,6 +145,7 @@ enum class TruncationSituation {
     CANNOT_TRUNCATE,
     UNSIGNED_TO_FLOAT,
     SIGNED_TO_FLOAT,
+    FLOAT_TO_INTEGRAL,
     UNEXPLORED,
 };
 
@@ -156,6 +171,12 @@ constexpr TruncationSituation categorize_truncation_situation() {
                                                       : TruncationSituation::SIGNED_TO_FLOAT);
     }
 
+    if (std::is_floating_point<Source>::value) {
+        if (std::is_integral<Dest>::value) {
+            return TruncationSituation::FLOAT_TO_INTEGRAL;
+        }
+    }
+
     return TruncationSituation::UNEXPLORED;
 }
 
@@ -189,6 +210,11 @@ struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::SIGNED_TO_FLOAT
     }
 };
 
+template <typename Source, typename Dest>
+struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::FLOAT_TO_INTEGRAL> {
+    static constexpr bool will_static_cast_truncate(Source x) { return std::trunc(x) != x; }
+};
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Main implementation:
 
diff --git a/au/code/au/static_cast_checkers_test.cc b/au/code/au/static_cast_checkers_test.cc
index 58f792c4..936f74f1 100644
--- a/au/code/au/static_cast_checkers_test.cc
+++ b/au/code/au/static_cast_checkers_test.cc
@@ -43,6 +43,16 @@ TEST(WillStaticCastOverflow, FalseWhenDestBoundsContainsSourceBounds) {
     EXPECT_FALSE(will_static_cast_overflow<float>(std::numeric_limits<uint64_t>::max()));
 }
 
+TEST(WillStaticCastOverflow, DependsOnTypeLimitsForFloatToInt) {
+    EXPECT_TRUE(will_static_cast_overflow<uint8_t>(-0.0001));
+    EXPECT_FALSE(will_static_cast_overflow<uint8_t>(0.0000));
+    EXPECT_FALSE(will_static_cast_overflow<uint8_t>(0.0001));
+
+    EXPECT_FALSE(will_static_cast_overflow<uint8_t>(254.9999));
+    EXPECT_FALSE(will_static_cast_overflow<uint8_t>(255.0000));
+    EXPECT_TRUE(will_static_cast_overflow<uint8_t>(255.0001));
+}
+
 TEST(WillStaticCastTruncate, IntToFloatFalseForIntTypeThatCanFitInFloat) {
     EXPECT_FALSE(will_static_cast_truncate<float>(uint8_t{124}));
     EXPECT_FALSE(will_static_cast_truncate<double>(124));
@@ -74,5 +84,29 @@ TEST(WillStaticCastTruncate, AutomaticallyFalseForIntegralToIntegral) {
     EXPECT_FALSE(will_static_cast_truncate<int8_t>(uint64_t{9876543210u}));
 }
 
+TEST(WillStaticCastTruncate, TrueForFloatToIntIffInputHasAFractionalPart) {
+    EXPECT_TRUE(will_static_cast_truncate<uint8_t>(-0.1));
+    EXPECT_FALSE(will_static_cast_truncate<uint8_t>(0.0));
+    EXPECT_TRUE(will_static_cast_truncate<uint8_t>(0.1));
+
+    EXPECT_TRUE(will_static_cast_truncate<uint8_t>(254.9));
+    EXPECT_FALSE(will_static_cast_truncate<uint8_t>(255.0));
+    EXPECT_TRUE(will_static_cast_truncate<uint8_t>(255.1));
+}
+
+TEST(a, b) {
+    using Source = uint8_t;
+    using Dest = float;
+    using Common = std::common_type_t<Source, Dest>;
+
+    constexpr auto val = Source{124};
+    EXPECT_FALSE(will_static_cast_overflow<Common>(val));
+    EXPECT_FALSE(will_static_cast_truncate<Common>(val));
+
+    constexpr auto intermediate = static_cast<Common>(val);
+    EXPECT_FALSE(will_static_cast_overflow<Dest>(intermediate));
+    EXPECT_FALSE(will_static_cast_truncate<Dest>(intermediate));
+}
+
 }  // namespace detail
 }  // namespace au
diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index 2d607c5a..b50b4041 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -27,6 +27,18 @@
 namespace au {
 namespace detail {
 
+template <typename U, typename R>
+Quantity<U, R> next_higher_quantity(Quantity<U, R> q) {
+    static_assert(std::is_floating_point<R>::value, "");
+    return make_quantity<U>(std::nextafter(q.in(U{}), std::numeric_limits<R>::infinity()));
+}
+
+template <typename U, typename R>
+Quantity<U, R> next_lower_quantity(Quantity<U, R> q) {
+    static_assert(std::is_floating_point<R>::value, "");
+    return make_quantity<U>(std::nextafter(q.in(U{}), -std::numeric_limits<R>::infinity()));
+}
+
 template <typename T>
 struct Tag {};
 
@@ -219,9 +231,27 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_F
             return {false};
         }
 
-        const auto next_destination = make_quantity<DestUnitT>(
-            std::nextafter(destination.in(DestUnitT{}), std::numeric_limits<DestRepT>::infinity()));
-        if (next_destination.template coerce_as<RepT>(UnitT{}) == value) {
+        for (const auto &q :
+             {next_lower_quantity(destination), next_higher_quantity(destination)}) {
+            if (q.template coerce_as<RepT>(UnitT{}) == value) {
+                return {false, "Within expected floating point error"};
+            }
+        }
+
+        return {true};
+    }
+};
+
+template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
+struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_INTEGRAL> {
+    static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
+                                    const Quantity<DestUnitT, DestRepT> &,
+                                    const Quantity<UnitT, RepT> &round_trip) {
+        if (round_trip == value) {
+            return {false};
+        }
+
+        if (next_higher_quantity(round_trip) == value || next_lower_quantity(round_trip) == value) {
             return {false, "Within expected floating point error"};
         }
 
@@ -229,6 +259,20 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_F
     }
 };
 
+template <typename T>
+struct RepForImpl : stdx::type_identity<T> {};
+template <typename T>
+using RepFor = typename RepForImpl<T>::type;
+template <typename U, typename R>
+struct RepForImpl<Quantity<U, R>> : stdx::type_identity<R> {};
+
+template <typename T>
+std::string print_to_string(const T &value) {
+    std::ostringstream oss;
+    oss << std::setprecision(std::numeric_limits<RepFor<T>>::digits10 + 1u) << value;
+    return oss.str();
+}
+
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT, TestCategory Cat>
 struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat> {
     using LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>::check_for_loss;
@@ -246,8 +290,8 @@ struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>
             std::cout << "Error found for <" << type_name<RepT>() << ">(" << unit_label(UnitT{})
                       << ") -> <" << type_name<DestRepT>() << ">(" << unit_label(DestUnitT{})
                       << ")! " << std::endl
-                      << "Initial value: " << value << std::endl
-                      << "Round trip:    " << round_trip << std::endl
+                      << "Initial value: " << print_to_string(value) << std::endl
+                      << "Round trip:    " << print_to_string(round_trip) << std::endl
                       << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
                       << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl
                       << "Extra comments: " << loss_check.comment << std::endl;
diff --git a/fuzz/quantity_runtime_conversion_checkers_test.cc b/fuzz/quantity_runtime_conversion_checkers_test.cc
index 1a47a851..16fa4ed3 100644
--- a/fuzz/quantity_runtime_conversion_checkers_test.cc
+++ b/fuzz/quantity_runtime_conversion_checkers_test.cc
@@ -131,6 +131,8 @@ void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
     std::terminate();
 }
 
+TEST(a, b) { explore_conversion<float>(meters(int8_t{-26}), yards); }
+
 template <typename T>
 class QuantityRuntimeConversionChecker : public ::testing::Test {};
 

From ca42b6786cdf213ef36d67a34105a42c5b8574e7 Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 15:22:24 -0500
Subject: [PATCH 8/9] More float stuff, but probably wrong direction

We should consistently hew to the convenient fiction that floating point
types do not lose precision.
---
 fuzz/quantity_runtime_conversion_check.cc     | 74 ++++++++++++++-----
 ...antity_runtime_conversion_checkers_test.cc | 22 +++++-
 2 files changed, 78 insertions(+), 18 deletions(-)

diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index b50b4041..bfb4364f 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -27,16 +27,32 @@
 namespace au {
 namespace detail {
 
+template <typename T>
+T next_higher(T x, std::size_t n = 1u) {
+    static_assert(std::is_floating_point<T>::value, "");
+    while (n-- > 0u) {
+        x = std::nextafter(x, std::numeric_limits<T>::infinity());
+    }
+    return x;
+}
+
+template <typename T>
+T next_lower(T x, std::size_t n = 1u) {
+    static_assert(std::is_floating_point<T>::value, "");
+    while (n-- > 0u) {
+        x = std::nextafter(x, -std::numeric_limits<T>::infinity());
+    }
+    return x;
+}
+
 template <typename U, typename R>
-Quantity<U, R> next_higher_quantity(Quantity<U, R> q) {
-    static_assert(std::is_floating_point<R>::value, "");
-    return make_quantity<U>(std::nextafter(q.in(U{}), std::numeric_limits<R>::infinity()));
+Quantity<U, R> next_higher_quantity(Quantity<U, R> q, std::size_t n = 1u) {
+    return make_quantity<U>(next_higher(q.in(U{}), n));
 }
 
 template <typename U, typename R>
-Quantity<U, R> next_lower_quantity(Quantity<U, R> q) {
-    static_assert(std::is_floating_point<R>::value, "");
-    return make_quantity<U>(std::nextafter(q.in(U{}), -std::numeric_limits<R>::infinity()));
+Quantity<U, R> next_lower_quantity(Quantity<U, R> q, std::size_t n = 1u) {
+    return make_quantity<U>(next_lower(q.in(U{}), n));
 }
 
 template <typename T>
@@ -203,22 +219,42 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_I
     }
 };
 
+// This is very lazy.  The actual epsilon depends on the _size of the conversion factor_.
+//
+// However, we're using a small and fixed number of conversion factors.  This is good enough to get
+// us started.  Later on, we can explore the effects of more extreme conversion factors, and see
+// whether they introduce any categorically new cases.
+template <typename T>
+struct FloatingPointRoundTripEpsilon;
+template <>
+struct FloatingPointRoundTripEpsilon<float> {
+    // Adjust value as needed when we encounter failures that we don't think are failures.
+    static constexpr float value() { return 2.0e-4f; }
+};
+template <>
+struct FloatingPointRoundTripEpsilon<double> {
+    static constexpr double value() { return 1.0e-10; }
+};
+
 template <typename RepT, typename UnitT, typename DestRepT, typename DestUnitT>
 struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_FLOAT> {
     static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
                                     const Quantity<DestUnitT, DestRepT> &,
                                     const Quantity<UnitT, RepT> &round_trip) {
-        using src_lim = std::numeric_limits<RepT>;
-        using dest_lim = std::numeric_limits<DestRepT>;
-
-        const RepT val_as_dest = static_cast<DestRepT>(value.in(UnitT{}));
-        const auto min_ok = make_quantity<UnitT>(std::nextafter(
-            static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::lowest())), src_lim::lowest()));
-        const auto max_ok = make_quantity<UnitT>(std::nextafter(
-            static_cast<RepT>(std::nextafter(val_as_dest, dest_lim::max())), src_lim::max()));
+        const auto sign = value < ZERO ? -1 : 1;
+        const auto min_ok = value * (1 - sign * FloatingPointRoundTripEpsilon<RepT>::value());
+        const auto max_ok = value * (1 + sign * FloatingPointRoundTripEpsilon<RepT>::value());
+
+        std::ostringstream oss;
+        oss << "Breakdown:" << std::setprecision(std::numeric_limits<RepT>::digits10 + 1u)
+            << std::endl
+            << "  Initial:    " << value << std::endl
+            << "  Min OK:     " << min_ok << std::endl
+            << "  Round trip: " << round_trip << std::endl
+            << "  Max OK:     " << max_ok << std::endl;
 
         const bool actual_loss = (round_trip < min_ok) || (round_trip > max_ok);
-        return {actual_loss};
+        return {actual_loss, oss.str()};
     }
 };
 
@@ -231,8 +267,12 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_F
             return {false};
         }
 
-        for (const auto &q :
-             {next_lower_quantity(destination), next_higher_quantity(destination)}) {
+        for (const auto &q : {
+                 next_lower_quantity(destination, 2u),
+                 next_lower_quantity(destination),
+                 next_higher_quantity(destination),
+                 next_higher_quantity(destination, 2u),
+             }) {
             if (q.template coerce_as<RepT>(UnitT{}) == value) {
                 return {false, "Within expected floating point error"};
             }
diff --git a/fuzz/quantity_runtime_conversion_checkers_test.cc b/fuzz/quantity_runtime_conversion_checkers_test.cc
index 16fa4ed3..9b3aaef2 100644
--- a/fuzz/quantity_runtime_conversion_checkers_test.cc
+++ b/fuzz/quantity_runtime_conversion_checkers_test.cc
@@ -111,6 +111,9 @@ void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
     std::cout << "\nConvert to target" << std::endl;
     std::cout << "As common rep : " << intermediate << "\n";
 
+    std::cout << "\nConversion factor" << std::endl;
+    std::cout << "Exact value:    " << mag_label(unit_ratio(U{}, TargetUnit{})) << "\n";
+
     const auto destination = q.template as<TargetR>(TargetUnit{});
     std::cout << "As target rep : " << destination << "\n";
     std::cout << "  expect trunc: " << will_truncate<Common>(destination) << "\n";
@@ -127,11 +130,28 @@ void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
     const auto round_trip = destination.template as<R>(U{});
     std::cout << "As initial rep: " << round_trip << "\n";
 
+    if (std::is_floating_point<R>::value) {
+        std::size_t dist = 0u;
+        auto x = round_trip.in(U{});
+        bool got_right_answer = true;
+        while (x != q.in(U{})) {
+            x = std::nextafter(x, q.in(U{}));
+            ++dist;
+            if (dist > 1000u) {
+                got_right_answer = false;
+                break;
+            }
+        }
+        std::cout << "Difference is " << dist << (got_right_answer ? "" : " (truncated)")
+                  << " ULPs\n";
+        std::cout << "Relative error is " << as_raw_number((round_trip - q) / q) << "\n";
+    }
+
     std::cout.flush();
     std::terminate();
 }
 
-TEST(a, b) { explore_conversion<float>(meters(int8_t{-26}), yards); }
+TEST(a, b) { explore_conversion<float>(meters(-13441457), miles); }
 
 template <typename T>
 class QuantityRuntimeConversionChecker : public ::testing::Test {};

From 1f936840ffef5ee74684d528afbefc73670dafce Mon Sep 17 00:00:00 2001
From: Chip Hogg <chogg@aurora.tech>
Date: Sat, 7 Dec 2024 19:40:51 -0500
Subject: [PATCH 9/9] More playing

---
 au/code/au/static_cast_checkers.hh            | 33 +-----------
 au/code/au/static_cast_checkers_test.cc       |  6 +--
 fuzz/quantity_runtime_conversion_check.cc     | 50 ++++++++++++-------
 ...antity_runtime_conversion_checkers_test.cc |  9 +++-
 4 files changed, 45 insertions(+), 53 deletions(-)

diff --git a/au/code/au/static_cast_checkers.hh b/au/code/au/static_cast_checkers.hh
index 83ea1246..2e3fe53c 100644
--- a/au/code/au/static_cast_checkers.hh
+++ b/au/code/au/static_cast_checkers.hh
@@ -143,8 +143,6 @@ struct StaticCastOverflowImpl<Source, Dest, OverflowSituation::DEST_BOUNDS_CONTA
 
 enum class TruncationSituation {
     CANNOT_TRUNCATE,
-    UNSIGNED_TO_FLOAT,
-    SIGNED_TO_FLOAT,
     FLOAT_TO_INTEGRAL,
     UNEXPLORED,
 };
@@ -159,16 +157,7 @@ constexpr TruncationSituation categorize_truncation_situation() {
     }
 
     if (std::is_integral<Source>::value) {
-        if (std::is_integral<Dest>::value) {
-            return TruncationSituation::CANNOT_TRUNCATE;
-        }
-
-        static_assert(std::numeric_limits<Dest>::radix == std::numeric_limits<Source>::radix,
-                      "No attempt yet to support mixed-radix");
-        return (std::numeric_limits<Dest>::digits >= std::numeric_limits<Source>::digits)
-                   ? TruncationSituation::CANNOT_TRUNCATE
-                   : (std::is_unsigned<Source>::value ? TruncationSituation::UNSIGNED_TO_FLOAT
-                                                      : TruncationSituation::SIGNED_TO_FLOAT);
+        return TruncationSituation::CANNOT_TRUNCATE;
     }
 
     if (std::is_floating_point<Source>::value) {
@@ -190,26 +179,6 @@ struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::CANNOT_TRUNCATE
     static constexpr bool will_static_cast_truncate(Source) { return false; }
 };
 
-template <typename Source, typename Dest>
-struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::UNSIGNED_TO_FLOAT> {
-    static constexpr bool will_static_cast_truncate(Source x) {
-        constexpr auto MIN_NON_REPRESENTABLE_VAL =
-            (Source{1u} << std::numeric_limits<Dest>::digits) + 1u;
-        return (x >= MIN_NON_REPRESENTABLE_VAL) && (static_cast<Source>(static_cast<Dest>(x)) != x);
-    }
-};
-
-template <typename Source, typename Dest>
-struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::SIGNED_TO_FLOAT> {
-    static constexpr bool will_static_cast_truncate(Source x) {
-        constexpr auto MIN_POS_NON_REPRESENTABLE_VAL =
-            (Source{1} << (std::numeric_limits<Dest>::digits - 1)) + 1;
-        constexpr auto MAX_NEG_NON_REPRESENTABLE_VAL = -MIN_POS_NON_REPRESENTABLE_VAL;
-        return (x >= MIN_POS_NON_REPRESENTABLE_VAL || x <= MAX_NEG_NON_REPRESENTABLE_VAL) &&
-               (static_cast<Source>(static_cast<Dest>(x)) != x);
-    }
-};
-
 template <typename Source, typename Dest>
 struct StaticCastTruncateImpl<Source, Dest, TruncationSituation::FLOAT_TO_INTEGRAL> {
     static constexpr bool will_static_cast_truncate(Source x) { return std::trunc(x) != x; }
diff --git a/au/code/au/static_cast_checkers_test.cc b/au/code/au/static_cast_checkers_test.cc
index 936f74f1..a6f33dc1 100644
--- a/au/code/au/static_cast_checkers_test.cc
+++ b/au/code/au/static_cast_checkers_test.cc
@@ -66,15 +66,15 @@ TEST(WillStaticCastTruncate, IntToFloatFalseForIntTypeThatCanFitInFloat) {
     EXPECT_FALSE(will_static_cast_truncate<double>(std::numeric_limits<uint32_t>::max() - 1));
 }
 
-TEST(WillStaticCastTruncate, IntToFloatDependsOnValueInGeneral) {
+TEST(WillStaticCastTruncate, IntToFloatFalseByConvention) {
     static_assert(std::numeric_limits<float>::radix == 2, "Test assumes binary");
 
     constexpr auto first_unrepresentable = (1 << std::numeric_limits<float>::digits) + 1;
     EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable - 2));
     EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable - 1));
-    EXPECT_TRUE(will_static_cast_truncate<float>(first_unrepresentable + 0));
+    EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable + 0));  // Nonrepresentable.
     EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable + 1));
-    EXPECT_TRUE(will_static_cast_truncate<float>(first_unrepresentable + 2));
+    EXPECT_FALSE(will_static_cast_truncate<float>(first_unrepresentable + 2));  // Nonrepresentable.
 }
 
 TEST(WillStaticCastTruncate, AutomaticallyFalseForIntegralToIntegral) {
diff --git a/fuzz/quantity_runtime_conversion_check.cc b/fuzz/quantity_runtime_conversion_check.cc
index bfb4364f..93736f35 100644
--- a/fuzz/quantity_runtime_conversion_check.cc
+++ b/fuzz/quantity_runtime_conversion_check.cc
@@ -16,6 +16,7 @@
 #include <limits>
 #include <string>
 
+#include "au/math.hh"
 #include "au/testing.hh"
 #include "au/units/inches.hh"
 #include "au/units/meters.hh"
@@ -229,7 +230,7 @@ struct FloatingPointRoundTripEpsilon;
 template <>
 struct FloatingPointRoundTripEpsilon<float> {
     // Adjust value as needed when we encounter failures that we don't think are failures.
-    static constexpr float value() { return 2.0e-4f; }
+    static constexpr float value() { return 1.0e-3f; }
 };
 template <>
 struct FloatingPointRoundTripEpsilon<double> {
@@ -263,22 +264,30 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::INTEGRAL_TO_F
     static LossCheck check_for_loss(const Quantity<UnitT, RepT> &value,
                                     const Quantity<DestUnitT, DestRepT> &destination,
                                     const Quantity<UnitT, RepT> &round_trip) {
-        if (round_trip == value) {
-            return {false};
+        auto one_pct = value / 100;
+        if (std::is_signed<RepT>::value && value < ZERO) {
+            one_pct = -one_pct;
         }
+        const auto dx = one_pct + make_quantity<UnitT>(RepT{1});
 
-        for (const auto &q : {
-                 next_lower_quantity(destination, 2u),
-                 next_lower_quantity(destination),
-                 next_higher_quantity(destination),
-                 next_higher_quantity(destination, 2u),
-             }) {
-            if (q.template coerce_as<RepT>(UnitT{}) == value) {
-                return {false, "Within expected floating point error"};
-            }
-        }
+        constexpr auto lowest = std::numeric_limits<Quantity<UnitT, RepT>>::lowest();
+        const auto min_ok = (lowest + dx > value) ? lowest : rep_cast<RepT>(value - dx);
 
-        return {true};
+        constexpr auto highest = std::numeric_limits<Quantity<UnitT, RepT>>::max();
+        const auto max_ok = (highest - dx < value) ? highest : rep_cast<RepT>(value + dx);
+
+        std::ostringstream oss;
+        oss << "We went through floating point; so, taking a very liberal margin.  Breakdown:"
+            << std::endl
+            << "  Initial:    " << value << std::endl
+            << "  Min OK:     " << min_ok << std::endl
+            << "  Round trip: " << round_trip << std::endl
+            << "  Max OK:     " << max_ok << std::endl;
+
+        return {
+            round_trip < min_ok || round_trip > max_ok,
+            oss.str(),
+        };
     }
 };
 
@@ -291,8 +300,11 @@ struct LossChecker<RepT, UnitT, DestRepT, DestUnitT, TestCategory::FLOAT_TO_INTE
             return {false};
         }
 
-        if (next_higher_quantity(round_trip) == value || next_lower_quantity(round_trip) == value) {
-            return {false, "Within expected floating point error"};
+        if (!std::is_same<UnitRatioT<UnitT, DestUnitT>, decltype(mag<1>())>::value) {
+            if (next_higher_quantity(round_trip) == value ||
+                next_lower_quantity(round_trip) == value) {
+                return {false, "Within expected floating point error"};
+            }
         }
 
         return {true};
@@ -309,7 +321,7 @@ struct RepForImpl<Quantity<U, R>> : stdx::type_identity<R> {};
 template <typename T>
 std::string print_to_string(const T &value) {
     std::ostringstream oss;
-    oss << std::setprecision(std::numeric_limits<RepFor<T>>::digits10 + 1u) << value;
+    oss << std::setprecision(std::numeric_limits<RepFor<T>>::digits10 + 3u) << value;
     return oss.str();
 }
 
@@ -319,6 +331,8 @@ struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>
 
     static void test(const Quantity<UnitT, RepT> &value) {
         const bool expect_loss = is_conversion_lossy<DestRepT>(value, DestUnitT{});
+        const bool expect_trunc = will_conversion_truncate<DestRepT>(value, DestUnitT{});
+        const bool expect_overflow = will_conversion_overflow<DestRepT>(value, DestUnitT{});
 
         const auto destination = value.template coerce_as<DestRepT>(DestUnitT{});
         const auto round_trip = destination.template coerce_as<RepT>(UnitT{});
@@ -333,6 +347,8 @@ struct NominalTestBodyImpl : LossChecker<RepT, UnitT, DestRepT, DestUnitT, Cat>
                       << "Initial value: " << print_to_string(value) << std::endl
                       << "Round trip:    " << print_to_string(round_trip) << std::endl
                       << "Expect loss: " << (expect_loss ? "true" : "false") << std::endl
+                      << "     (trunc: " << (expect_trunc ? "true" : "false") << ")" << std::endl
+                      << "     (overf: " << (expect_overflow ? "true" : "false") << ")" << std::endl
                       << "Actual loss: " << (actual_loss ? "true" : "false") << std::endl
                       << "Extra comments: " << loss_check.comment << std::endl;
             std::terminate();
diff --git a/fuzz/quantity_runtime_conversion_checkers_test.cc b/fuzz/quantity_runtime_conversion_checkers_test.cc
index 9b3aaef2..7bcda295 100644
--- a/fuzz/quantity_runtime_conversion_checkers_test.cc
+++ b/fuzz/quantity_runtime_conversion_checkers_test.cc
@@ -122,11 +122,18 @@ void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
     std::cout << "Back to common: " << static_cast<Common>(destination.in(TargetUnit{})) << " ("
               << type_name<Common>() << ")\n";
 
+    std::cout << "  Will conv trunc? " << will_conversion_truncate(destination, U{}) << "\n";
+    std::cout << "  Will conv overf? " << will_conversion_overflow(destination, U{}) << "\n";
+
     const auto intermediate_back = destination.template as<Common>(U{});
 
     std::cout << "\nConvert back to initial unit" << std::endl;
     std::cout << "As common rep : " << intermediate_back << "\n";
 
+    std::cout << "\nStatic cast back to initial rep" << std::endl;
+    std::cout << "  expect trunc: " << will_truncate<R>(intermediate_back) << "\n";
+    std::cout << "  expect overf: " << will_overflow<R>(intermediate_back) << "\n";
+
     const auto round_trip = destination.template as<R>(U{});
     std::cout << "As initial rep: " << round_trip << "\n";
 
@@ -151,7 +158,7 @@ void explore_conversion(Quantity<U, R> q, TargetUnitSlot) {
     std::terminate();
 }
 
-TEST(a, b) { explore_conversion<float>(meters(-13441457), miles); }
+TEST(a, b) { explore_conversion<int>(miles(-114.269012f), inches); }
 
 template <typename T>
 class QuantityRuntimeConversionChecker : public ::testing::Test {};