[libcxx-commits] [libcxx] [libc++] Refactor midpoint test and clean unused functions (PR #175388)

[Hristo Hristov via libcxx-commits]

================
@@ -5,140 +5,158 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// REQUIRES: std-at-least-c++20
+
 // <numeric>
 
 // template <class _Tp>
 // _Tp midpoint(_Tp __a, _Tp __b) noexcept
-//
+// Constraints:
+//   - T is an arithmetic type other than bool.
 
-#include <stdint.h>
-#include <limits>
-#include <numeric>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <limits>
+#include <numeric>
+#include <type_traits>
+
 #include "test_macros.h"
 
 template <typename T>
-void signed_test()
-{
-    constexpr T zero{0};
-    constexpr T one{1};
-    constexpr T two{2};
-    constexpr T three{3};
-    constexpr T four{4};
-
-    ASSERT_SAME_TYPE(decltype(std::midpoint(T(), T())), T);
-    ASSERT_NOEXCEPT(          std::midpoint(T(), T()));
-    using limits = std::numeric_limits<T>;
-
-    static_assert(std::midpoint(one, three) == two, "");
-    static_assert(std::midpoint(three, one) == two, "");
-
-    assert(std::midpoint(zero, zero) == zero);
-    assert(std::midpoint(zero, two)  == one);
-    assert(std::midpoint(two, zero)  == one);
-    assert(std::midpoint(two, two)   == two);
-
-    assert(std::midpoint(one, four)    == two);
-    assert(std::midpoint(four, one)    == three);
-    assert(std::midpoint(three, four)  == three);
-    assert(std::midpoint(four, three)  == four);
-
-    assert(std::midpoint(T( 3), T( 4)) == T(3));
-    assert(std::midpoint(T( 4), T( 3)) == T(4));
-    assert(std::midpoint(T(-3), T( 4)) == T(0));
-    assert(std::midpoint(T(-4), T( 3)) == T(-1));
-    assert(std::midpoint(T( 3), T(-4)) == T(0));
-    assert(std::midpoint(T( 4), T(-3)) == T(1));
-    assert(std::midpoint(T(-3), T(-4)) == T(-3));
-    assert(std::midpoint(T(-4), T(-3)) == T(-4));
-
-    static_assert(std::midpoint(limits::min(), limits::max()) == T(-1), "");
-    static_assert(std::midpoint(limits::max(), limits::min()) == T( 0), "");
-
-    static_assert(std::midpoint(limits::min(), T(6)) == limits::min()/2 + 3, "");
-    assert(       std::midpoint(T(6), limits::min()) == limits::min()/2 + 3);
-    assert(       std::midpoint(limits::max(), T(6)) == limits::max()/2 + 4);
-    static_assert(std::midpoint(T(6), limits::max()) == limits::max()/2 + 3, "");
-
-    assert(       std::midpoint(limits::min(), T(-6)) == limits::min()/2 - 3);
-    static_assert(std::midpoint(T(-6), limits::min()) == limits::min()/2 - 3, "");
-    static_assert(std::midpoint(limits::max(), T(-6)) == limits::max()/2 - 2, "");
-    assert(       std::midpoint(T(-6), limits::max()) == limits::max()/2 - 3);
+constexpr bool test_signed() {
+  ASSERT_SAME_TYPE(decltype(std::midpoint(T{}, T{})), T);
+  ASSERT_NOEXCEPT(std::midpoint(T{}, T{}));
+  using limits = std::numeric_limits<T>;
+
+  assert(std::midpoint(T{1}, T{3}) == T{2});
+  assert(std::midpoint(T{3}, T{1}) == T{2});
+
+  assert(std::midpoint(T{0}, T{0}) == T{0});
+  assert(std::midpoint(T{0}, T{2}) == T{1});
+  assert(std::midpoint(T{2}, T{0}) == T{1});
+  assert(std::midpoint(T{2}, T{2}) == T{2});
+
+  assert(std::midpoint(T{1}, T{4}) == T{2});
+  assert(std::midpoint(T{4}, T{1}) == T{3});
+  assert(std::midpoint(T{3}, T{4}) == T{3});
+  assert(std::midpoint(T{4}, T{3}) == T{4});
+
+  assert(std::midpoint(T{-3}, T{4}) == T{0});
+  assert(std::midpoint(T{-4}, T{3}) == T{-1});
+  assert(std::midpoint(T{3}, T{-4}) == T{0});
+  assert(std::midpoint(T{4}, T{-3}) == T{1});
+  assert(std::midpoint(T{-3}, T{-4}) == T{-3});
+  assert(std::midpoint(T{-4}, T{-3}) == T{-4});
+
+  assert(std::midpoint(limits::min(), limits::max()) == T{-1});
+  assert(std::midpoint(limits::max(), limits::min()) == T{0});
+
+  assert(std::midpoint(limits::min(), T{6}) == T{limits::min() / 2 + 3});
+  assert(std::midpoint(T{6}, limits::min()) == T{limits::min() / 2 + 3});
+
+  assert(std::midpoint(limits::max(), T{6}) == T{limits::max() / 2 + 4});
+  assert(std::midpoint(T{6}, limits::max()) == T{limits::max() / 2 + 3});
+
+  assert(std::midpoint(limits::min(), T{-6}) == T{limits::min() / 2 - 3});
+  assert(std::midpoint(T{-6}, limits::min()) == T{limits::min() / 2 - 3});
+
+  assert(std::midpoint(limits::max(), T{-6}) == T{limits::max() / 2 - 2});
+  assert(std::midpoint(T{-6}, limits::max()) == T{limits::max() / 2 - 3});
+
+  return true;
 }
 
 template <typename T>
-void unsigned_test()
-{
-    constexpr T zero{0};
-    constexpr T one{1};
-    constexpr T two{2};
-    constexpr T three{3};
-    constexpr T four{4};
-
-    ASSERT_SAME_TYPE(decltype(std::midpoint(T(), T())), T);
-    ASSERT_NOEXCEPT(          std::midpoint(T(), T()));
-    using limits = std::numeric_limits<T>;
-    const T half_way = (limits::max() - limits::min())/2;
-
-    static_assert(std::midpoint(one, three) == two, "");
-    static_assert(std::midpoint(three, one) == two, "");
-
-    assert(std::midpoint(zero, zero) == zero);
-    assert(std::midpoint(zero, two)  == one);
-    assert(std::midpoint(two, zero)  == one);
-    assert(std::midpoint(two, two)   == two);
-
-    assert(std::midpoint(one, four)    == two);
-    assert(std::midpoint(four, one)    == three);
-    assert(std::midpoint(three, four)  == three);
-    assert(std::midpoint(four, three)  == four);
-
-    assert(std::midpoint(limits::min(), limits::max()) == T(half_way));
-    assert(std::midpoint(limits::max(), limits::min()) == T(half_way + 1));
-
-    static_assert(std::midpoint(limits::min(), T(6)) == limits::min()/2 + 3, "");
-    assert(       std::midpoint(T(6), limits::min()) == limits::min()/2 + 3);
-    assert(       std::midpoint(limits::max(), T(6)) == half_way + 4);
-    static_assert(std::midpoint(T(6), limits::max()) == half_way + 3, "");
-}
+constexpr bool test_unsigned() {
+  ASSERT_SAME_TYPE(decltype(std::midpoint(T{}, T{})), T);
+  ASSERT_NOEXCEPT(std::midpoint(T{}, T{}));
 
+  using limits     = std::numeric_limits<T>;
+  const T half_way = (limits::max() - limits::min()) / 2;
 
-int main(int, char**)
-{
-    signed_test<signed char>();
-    signed_test<short>();
-    signed_test<int>();
-    signed_test<long>();
-    signed_test<long long>();
+  assert(std::midpoint(T{1}, T{3}) == T{2});
+  assert(std::midpoint(T{3}, T{1}) == T{2});
 
-    signed_test<std::int8_t>();
-    signed_test<std::int16_t>();
-    signed_test<std::int32_t>();
-    signed_test<std::int64_t>();
+  assert(std::midpoint(T{0}, T{0}) == T{0});
+  assert(std::midpoint(T{0}, T{2}) == T{1});
+  assert(std::midpoint(T{2}, T{0}) == T{1});
+  assert(std::midpoint(T{2}, T{2}) == T{2});
 
-    unsigned_test<unsigned char>();
-    unsigned_test<unsigned short>();
-    unsigned_test<unsigned int>();
-    unsigned_test<unsigned long>();
-    unsigned_test<unsigned long long>();
+  assert(std::midpoint(T{1}, T{4}) == T{2});
+  assert(std::midpoint(T{4}, T{1}) == T{3});
+  assert(std::midpoint(T{3}, T{4}) == T{3});
+  assert(std::midpoint(T{4}, T{3}) == T{4});
 
-    unsigned_test<std::uint8_t>();
-    unsigned_test<std::uint16_t>();
-    unsigned_test<std::uint32_t>();
-    unsigned_test<std::uint64_t>();
+  assert(std::midpoint(limits::min(), limits::max()) == half_way);
+  assert(std::midpoint(limits::max(), limits::min()) == T{half_way + 1});
+
+  assert(std::midpoint(limits::min(), T{6}) == T{3});
+  assert(std::midpoint(T{6}, limits::min()) == T{3});
+
+  assert(std::midpoint(limits::max(), T{6}) == T{half_way + 4});
+  assert(std::midpoint(T{6}, limits::max()) == T{half_way + 3});
+
+  return true;
+}
+
+template <typename T>
+constexpr bool test() {
+  if constexpr (std::is_signed_v<T>) {
+    return test_signed<T>();
+  } else {
+    return test_unsigned<T>();
+  }
+}
+
+template <typename T>
+concept has_midpoint = requires(T a, T b) { std::midpoint(a, b); };
+
+static void test_constraints() {
+  static_assert(!has_midpoint<bool>);
+  static_assert(!has_midpoint<const bool>);
+  static_assert(!has_midpoint<volatile bool>);
+  static_assert(!has_midpoint<const volatile bool>);
+}
 
+int main(int, char**) {
+  auto test_all = []<typename... Ts>() {
+    static_assert((test<Ts>() && ...));
+    (test<Ts>(), ...);
+  };
+  test_all.operator()<
----------------
Zingam wrote:

https://github.com/llvm/llvm-project/blob/4f90ce4e6ec20db592836421ce309aaab134c353/libcxx/test/support/type_algorithms.h#L51

I think is what you might want to use: `types::for_each(types::integer_types(), [](){});`

https://github.com/llvm/llvm-project/pull/175388