[libcxx-commits] [libcxx] 20245bb - [libc++][NFC] Format abs.pass.cpp test

[Nikolas Klauser via libcxx-commits]

Author: Nikolas Klauser
Date: 2025-06-19T10:41:12+02:00
New Revision: 20245bbf66977ca9de5a2b6e29e8617a3a5d9fb5

URL: https://github.com/llvm/llvm-project/commit/20245bbf66977ca9de5a2b6e29e8617a3a5d9fb5
DIFF: https://github.com/llvm/llvm-project/commit/20245bbf66977ca9de5a2b6e29e8617a3a5d9fb5.diff

LOG: [libc++][NFC] Format abs.pass.cpp test

I will modify the test in an upcoming PR. I'm formatting it now to avoid
a bunch of whitespace changes in that PR.

Added: 
    

Modified: 
    libcxx/test/std/numerics/c.math/abs.pass.cpp

Removed: 
    


################################################################################
diff  --git a/libcxx/test/std/numerics/c.math/abs.pass.cpp b/libcxx/test/std/numerics/c.math/abs.pass.cpp
index 03aae465c2573..51aee6e986836 100644
--- a/libcxx/test/std/numerics/c.math/abs.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/abs.pass.cpp
@@ -14,65 +14,59 @@
 
 #include "test_macros.h"
 
-template<class T>
-struct correct_size_int
-{
-    typedef typename std::conditional<sizeof(T) < sizeof(int), int, T>::type type;
+template <class T>
+struct correct_size_int {
+  typedef typename std::conditional<sizeof(T) < sizeof(int), int, T>::type type;
 };
 
 template <class Source, class Result>
-void test_abs()
-{
-    Source neg_val = -5;
-    Source pos_val = 5;
-    Result res = 5;
+void test_abs() {
+  Source neg_val = -5;
+  Source pos_val = 5;
+  Result res     = 5;
 
-    ASSERT_SAME_TYPE(decltype(std::abs(neg_val)), Result);
+  ASSERT_SAME_TYPE(decltype(std::abs(neg_val)), Result);
 
-    assert(std::abs(neg_val) == res);
-    assert(std::abs(pos_val) == res);
+  assert(std::abs(neg_val) == res);
+  assert(std::abs(pos_val) == res);
 }
 
-void test_big()
-{
-    long long int big_value = std::numeric_limits<long long int>::max(); // a value too big for ints to store
-    long long int negative_big_value = -big_value;
-    assert(std::abs(negative_big_value) == big_value); // make sure it doesn't get casted to a smaller type
+void test_big() {
+  long long int big_value          = std::numeric_limits<long long int>::max(); // a value too big for ints to store
+  long long int negative_big_value = -big_value;
+  assert(std::abs(negative_big_value) == big_value); // make sure it doesn't get casted to a smaller type
 }
 
 // The following is helpful to keep in mind:
 // 1byte == char <= short <= int <= long <= long long
 
-int main(int, char**)
-{
-    // On some systems char is unsigned.
-    // If that is the case, we should just test signed char twice.
-    typedef std::conditional<
-        std::is_signed<char>::value, char, signed char
-    >::type SignedChar;
+int main(int, char**) {
+  // On some systems char is unsigned.
+  // If that is the case, we should just test signed char twice.
+  typedef std::conditional< std::is_signed<char>::value, char, signed char >::type SignedChar;
 
-    // All types less than or equal to and not greater than int are promoted to int.
-    test_abs<short int, int>();
-    test_abs<SignedChar, int>();
-    test_abs<signed char, int>();
+  // All types less than or equal to and not greater than int are promoted to int.
+  test_abs<short int, int>();
+  test_abs<SignedChar, int>();
+  test_abs<signed char, int>();
 
-    // These three calls have specific overloads:
-    test_abs<int, int>();
-    test_abs<long int, long int>();
-    test_abs<long long int, long long int>();
+  // These three calls have specific overloads:
+  test_abs<int, int>();
+  test_abs<long int, long int>();
+  test_abs<long long int, long long int>();
 
-    // Here there is no guarantee that int is larger than int8_t so we
-    // use a helper type trait to conditional test against int.
-    test_abs<std::int8_t, correct_size_int<std::int8_t>::type>();
-    test_abs<std::int16_t, correct_size_int<std::int16_t>::type>();
-    test_abs<std::int32_t, correct_size_int<std::int32_t>::type>();
-    test_abs<std::int64_t, correct_size_int<std::int64_t>::type>();
+  // Here there is no guarantee that int is larger than int8_t so we
+  // use a helper type trait to conditional test against int.
+  test_abs<std::int8_t, correct_size_int<std::int8_t>::type>();
+  test_abs<std::int16_t, correct_size_int<std::int16_t>::type>();
+  test_abs<std::int32_t, correct_size_int<std::int32_t>::type>();
+  test_abs<std::int64_t, correct_size_int<std::int64_t>::type>();
 
-    test_abs<long double, long double>();
-    test_abs<double, double>();
-    test_abs<float, float>();
+  test_abs<long double, long double>();
+  test_abs<double, double>();
+  test_abs<float, float>();
 
-    test_big();
+  test_big();
 
-    return 0;
+  return 0;
 }