all: minor cleanups

2024-05-28 10:26:39 +02:00
parent b0ce072370
commit 3495d1affd
17 changed files with 136 additions and 113 deletions
@@ -420,8 +420,12 @@ struct TestBELE {
            constexpr T zero = {};
            constexpr T zero_copy = T::make(zero);
            assert_noexcept(zero_copy == 0);
+            assert_noexcept(!upx::has_single_bit(zero));
 #if defined(upx_is_constant_evaluated)
            static_assert(zero_copy == 0);
+            static_assert(zero_copy == zero);
+            static_assert(!upx::has_single_bit(zero));
+            static_assert(!upx::has_single_bit(zero_copy));
 #endif
        }
 #if defined(upx_is_constant_evaluated)
@@ -429,12 +433,15 @@ struct TestBELE {
            typedef typename T::integral_conversion_type U;
            constexpr T one = T::make(1);
            static_assert(one == 1);
+            static_assert(upx::has_single_bit(one));
            constexpr T four = T::make(one + 3);
            static_assert(four == 4);
+            static_assert(upx::has_single_bit(four));
            constexpr U all_bits_u = (U) T::make(U(0) - U(1));
            constexpr T all_bits = T::make(all_bits_u);
            static_assert(all_bits == all_bits_u);
            static_assert(all_bits == T::make(one - 2));
+            static_assert(!upx::has_single_bit(all_bits));
            static_assert(one == one);
            static_assert(!(one == four));
            static_assert(!(one == all_bits));
@@ -50,7 +50,7 @@ TEST_CASE("std::vector") {
 }

 /*************************************************************************
-// core util - UPX_CXX_DISABLE_xxx
+// core util: UPX_CXX_DISABLE_xxx, noncopyable
 **************************************************************************/

 namespace {
@@ -166,6 +166,23 @@ struct Z2_X2 : public X2 {

 } // namespace test_disable_new_delete

+TEST_CASE("upx::noncopyable") {
+    struct Test : private upx::noncopyable {
+        int v = 1;
+    };
+    Test t = {};
+    CHECK(t.v == 1);
+#if (ACC_CC_MSC) // MSVC thinks that Test is not std::is_trivially_copyable; true or compiler bug?
+    // @COMPILER_BUG @MSVC_BUG
+    t.v = 0;
+#else
+    mem_clear(&t);
+#endif
+    CHECK(t.v == 0);
+    constexpr Test x = {};
+    static_assert(x.v == 1);
+}
+
 /*************************************************************************
 // <type_traits>
 **************************************************************************/
@@ -190,6 +207,16 @@ static_assert(upx::is_same_any_v<size_t, unsigned, unsigned long, unsigned long
 // TODO later: CHERI
 static_assert(upx::is_same_any_v<upx_uintptr_t, unsigned, unsigned long, unsigned long long>);

+/*************************************************************************
+// <bit>
+**************************************************************************/
+
+static_assert(!upx::has_single_bit(0));
+static_assert(upx::has_single_bit(1));
+static_assert(upx::has_single_bit(2));
+static_assert(!upx::has_single_bit(3));
+static_assert(upx::has_single_bit(4));
+
 /*************************************************************************
 // <algorithm>
 **************************************************************************/
@@ -212,25 +239,35 @@ static_assert(upx::align_gap(4, 4) == 0);

 static_assert(upx::min<upx_int8_t>(1, 2) == 1);
 static_assert(upx::min<upx_int16_t>(1, 2) == 1);
-static_assert(upx::min(1, 2) == 1);
-static_assert(upx::min(1ll, 2ll) == 1);
+static_assert(upx::min<upx_int32_t>(1, 2) == 1);
+static_assert(upx::min<upx_int64_t>(1, 2) == 1);
 static_assert(upx::max<upx_int8_t>(1, 2) == 2);
 static_assert(upx::max<upx_int16_t>(1, 2) == 2);
+static_assert(upx::max<upx_int32_t>(1, 2) == 2);
+static_assert(upx::max<upx_int64_t>(1, 2) == 2);
+
+static_assert(upx::min(1, 2) == 1);
+static_assert(upx::min(1l, 2l) == 1);
+static_assert(upx::min(1ll, 2ll) == 1);
 static_assert(upx::max(1, 2) == 2);
+static_assert(upx::max(1l, 2l) == 2);
 static_assert(upx::max(1ll, 2ll) == 2);

-static_assert(upx::min(0, 0) == 0);
-static_assert(upx::min(0, 1) == 0);
-static_assert(upx::min(1, 0) == 0);
-static_assert(upx::max(0, 0) == 0);
-static_assert(upx::max(0, 1) == 1);
-static_assert(upx::max(1, 0) == 1);
-static_assert(upx::umin(0u, 0u) == 0u);
-static_assert(upx::umin(0u, 1u) == 0u);
-static_assert(upx::umin(1u, 0u) == 0u);
-static_assert(upx::umax(0u, 0u) == 0u);
-static_assert(upx::umax(0u, 1u) == 1u);
-static_assert(upx::umax(1u, 0u) == 1u);
+static_assert(upx::umin<upx_uint8_t>(1, 2) == 1);
+static_assert(upx::umin<upx_uint16_t>(1, 2) == 1);
+static_assert(upx::umin<upx_uint32_t>(1, 2) == 1);
+static_assert(upx::umin<upx_uint64_t>(1, 2) == 1);
+static_assert(upx::umax<upx_uint8_t>(1, 2) == 2);
+static_assert(upx::umax<upx_uint16_t>(1, 2) == 2);
+static_assert(upx::umax<upx_uint32_t>(1, 2) == 2);
+static_assert(upx::umax<upx_uint64_t>(1, 2) == 2);
+
+static_assert(upx::umin(1u, 2u) == 1);
+static_assert(upx::umin(1ul, 2ul) == 1);
+static_assert(upx::umin(1ull, 2ull) == 1);
+static_assert(upx::umax(1u, 2u) == 2);
+static_assert(upx::umax(1ul, 2ul) == 2);
+static_assert(upx::umax(1ull, 2ull) == 2);

 static_assert(upx::wrapping_add<upx_int8_t>(127, 2) == -127);
 static_assert(upx::wrapping_add<upx_int16_t>(32767, 2) == -32767);
@@ -241,6 +278,9 @@ static_assert(upx::wrapping_sub<upx_int16_t>(-32767, 2) == 32767);
 static_assert(upx::wrapping_sub(-2147483647, 2) == 2147483647);
 static_assert(upx::wrapping_sub(-9223372036854775807ll, 2ll) == 9223372036854775807ll);

+static_assert(upx::wrapping_add<upx_uint8_t>(255, 2) == 1);
+static_assert(upx::wrapping_sub<upx_uint8_t>(1, 2) == 255);
+
 /*************************************************************************
 // util
 **************************************************************************/
@@ -518,23 +558,6 @@ TEST_CASE("upx::ObjectDeleter 2") {
    }
 }

-TEST_CASE("upx::noncopyable") {
-    struct Test : private upx::noncopyable {
-        int v = 1;
-    };
-    Test t = {};
-    CHECK(t.v == 1);
-#if (ACC_CC_MSC) // MSVC thinks that Test is not std::is_trivially_copyable; true or compiler bug?
-    // @COMPILER_BUG @MSVC_BUG
-    t.v = 0;
-#else
-    mem_clear(&t);
-#endif
-    CHECK(t.v == 0);
-    constexpr Test x = {};
-    static_assert(x.v == 1);
-}
-
 /*************************************************************************
 // namespace upx::compile_time
 **************************************************************************/