xo-unit: test: verify natural_unit/scaled_unit is structural type

include/xo/unit/natural_unit.hpp

@@ -122,7 +122,7 @@ namespace xo {
                 return retval;
             }
 
-        private:
+        public: /* need public members so that a natural_unit instance can be a non-type template parameter (a structural type) */
             /** @brief the number of occupied slots in @c bpu_v_ **/
             std::size_t n_bpu_;
 

include/xo/unit/scaled_unit.hpp

@@ -24,9 +24,9 @@ namespace xo {
                 {}
 
             constexpr scaled_unit reciprocal() const {
-                return scaled_unit(nu_reciprocal(natural_unit_,
-                                                 1 / outer_scale_factor_,
-                                                 1.0 / outer_scale_sq_));
+                return scaled_unit(natural_unit_.reciprocal(),
+                                   1 / outer_scale_factor_,
+                                   1.0 / outer_scale_sq_);
             }
 
             natural_unit<Int> natural_unit_;

utest/CMakeLists.txt

@@ -6,6 +6,7 @@ set(SELF_SRCS
     Quantity.test.cpp
     bpu.test.cpp
     bu.test.cpp
+    natural_unit.test.cpp
     unit.test.cpp #quantity.test.cpp
 )
 

utest/bpu.test.cpp

@@ -9,7 +9,7 @@ namespace xo {
         using bpu64_type = bpu<std::int64_t>;
 
         /* compile-time test:
-         * verify we can use a bpu as a non-type template parameter.
+         * verify we can use a bpu64_type instance as a non-type template parameter.
          * Will need this for quantity<Repr, Int, natural_unit<Int>>
          */
         template <bpu64_type bpu>

utest/natural_unit.test.cpp

@@ -0,0 +1,37 @@
+/* @file natural_unit.test.cpp */
+
+#include "xo/unit/natural_unit.hpp"
+#include <catch2/catch.hpp>
+
+namespace xo {
+    namespace qty {
+        using nu64_type = natural_unit<std::int64_t>;
+
+        /* compile-time test:
+         * verify we can use an nu64_type instance as a non-type template parameter.
+         * Will need this for quantity<Repr, Int, natural_unit<Int>>
+         */
+        template <nu64_type nu>
+        constexpr nu_abbrev_type nu_mpl_abbrev = nu.abbrev();
+
+        TEST_CASE("natural_unit", "[natural_unit]") {
+            //constexpr bool c_debug_flag = false;
+
+            // can get bits from /dev/random by uncommenting the 2nd line below
+            //uint64_t seed = xxx;
+            //rng::Seed<xoshio256ss> seed;
+
+            //auto rng = xo::rng::xoshiro256ss(seed);
+
+            //scope log(XO_DEBUG2(c_debug_flag, "TEST_CASE.bpu"));
+            //log && log("(A)", xtag("foo", foo));
+
+            static_assert(nu_mpl_abbrev<nu::gram> == nu::gram.abbrev());
+            REQUIRE(nu_mpl_abbrev<nu::gram> == nu::gram.abbrev());
+
+        } /*TEST_CASE(natural_unit)*/
+    } /*namespace qty*/
+} /*namespace xo*/
+
+
+/* end natural_unit.test.cpp */

utest/scaled_unit.test.cpp

@@ -0,0 +1,41 @@
+/* @file scaled_unit.test.cpp */
+
+#include "xo/unit/scaled_unit.hpp"
+#include <catch2/catch.hpp>
+
+namespace xo {
+    namespace qty {
+        using su64_type = scaled_unit<std::int64_t>;
+
+        /* compile-time test:
+         * verify we can use an su64_type instance as a non-type template parameter.
+         * Will need this for quantity<Repr, Int, scaled_unit<Int>>
+         */
+        template <su64_type su>
+        constexpr su64_type su_reciprocal = su.reciprocal();
+
+        TEST_CASE("scaled_unit", "[scaled_unit]") {
+            //constexpr bool c_debug_flag = false;
+
+            // can get bits from /dev/random by uncommenting the 2nd line below
+            //uint64_t seed = xxx;
+            //rng::Seed<xoshio256ss> seed;
+
+            //auto rng = xo::rng::xoshiro256ss(seed);
+
+            //scope log(XO_DEBUG2(c_debug_flag, "TEST_CASE.bpu"));
+            //log && log("(A)", xtag("foo", foo));
+
+            static_assert(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.natural_unit_ == nu::gram.reciprocal());
+            REQUIRE(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.natural_unit_ == nu::gram.reciprocal());
+
+            static_assert(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.outer_scale_factor_ == 1);
+            REQUIRE(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.outer_scale_factor_ == 1);
+
+            static_assert(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.outer_scale_sq_ == 1.0);
+            REQUIRE(su_reciprocal<scaled_unit(nu::gram, xo::ratio::ratio(1L), 1)>.outer_scale_sq_ == 1.0);
+        } /*TEST_CASE(scaled_unit)*/
+    } /*namespace qty*/
+} /*namespace xo*/
+
+/* end scaled_unit.test.cpp */