refactor tests: do not extract tests into separate functions

Author: PaulXiCao

libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp

@@ -80,96 +80,48 @@ test_sort_()
 }
 
 template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> init_saw_tooth_pattern() {
-  std::array<int, N> array;
-  for (int i = 0, x = 0; i < N; ++i) {
+TEST_CONSTEXPR_CXX26 void test_larger_sorts() {
+  static_assert(N != 0);
+  static_assert(M != 0);
+
+  // create array length N filled with M different numbers
+  std::array<int, N> array_;
+  int* const array = array_.data();
+  int x            = 0;
+  for (int i = 0; i < N; ++i) {
     array[i] = x;
     if (++x == M)
       x = 0;
   }
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> sort_saw_tooth_pattern() {
-  std::array<int, N> array = init_saw_tooth_pattern<N, M>();
-  std::stable_sort(array.begin(), array.end());
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> sort_already_sorted() {
-  std::array<int, N> array = sort_saw_tooth_pattern<N, M>();
-  std::stable_sort(array.begin(), array.end());
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> sort_reversely_sorted() {
-  std::array<int, N> array = sort_saw_tooth_pattern<N, M>();
-  std::reverse(array.begin(), array.end());
-  std::stable_sort(array.begin(), array.end());
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> sort_swapped_sorted_ranges() {
-  std::array<int, N> array = sort_saw_tooth_pattern<N, M>();
-  std::swap_ranges(array.begin(), array.begin() + N / 2, array.begin() + N / 2);
-  std::stable_sort(array.begin(), array.end());
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 std::array<int, N> sort_reversely_swapped_sorted_ranges() {
-  std::array<int, N> array = sort_saw_tooth_pattern<N, M>();
-  std::reverse(array.begin(), array.end());
-  std::swap_ranges(array.begin(), array.begin() + N / 2, array.begin() + N / 2);
-  std::stable_sort(array.begin(), array.end());
-  return array;
-}
-
-template <int N, int M>
-TEST_CONSTEXPR_CXX26 void test_larger_sorts() {
-  static_assert(N > 0, "");
-  static_assert(M > 0, "");
-
-  { // test saw tooth pattern
-    std::array<int, N> array = sort_saw_tooth_pattern<N, M>();
-    assert(std::is_sorted(array.begin(), array.end()));
-  }
-
+  // test saw tooth pattern
+  std::stable_sort(array, array + N);
+  assert(std::is_sorted(array, array + N));
+  // test random pattern
 #if TEST_STD_VER >= 26
-  if !consteval
+  if !consteval // random-number generators not constexpr-friendly
 #endif
-  { // test random pattern
-    // random-number generators not constexpr-friendly
+  {
     static std::mt19937 randomness;
-    std::array<int, N> array = init_saw_tooth_pattern<N, M>();
-    std::shuffle(array.begin(), array.end(), randomness);
-    std::stable_sort(array.begin(), array.end());
-    assert(std::is_sorted(array.begin(), array.end()));
-  }
-
-  { // test sorted pattern
-    std::array<int, N> array = sort_already_sorted<N, M>();
-    assert(std::is_sorted(array.begin(), array.end()));
-  }
-
-  { // test reverse sorted pattern
-    std::array<int, N> array = sort_reversely_sorted<N, M>();
-    assert(std::is_sorted(array.begin(), array.end()));
-  }
-
-  { // test swap ranges 2 pattern
-    std::array<int, N> array = sort_swapped_sorted_ranges<N, M>();
-    assert(std::is_sorted(array.begin(), array.end()));
-  }
-
-  { // test reverse swap ranges 2 pattern
-    std::array<int, N> array = sort_reversely_swapped_sorted_ranges<N, M>();
-    assert(std::is_sorted(array.begin(), array.end()));
+    std::shuffle(array, array + N, randomness);
+    std::stable_sort(array, array + N);
+    assert(std::is_sorted(array, array + N));
   }
+  // test sorted pattern
+  std::stable_sort(array, array + N);
+  assert(std::is_sorted(array, array + N));
+  // test reverse sorted pattern
+  std::reverse(array, array + N);
+  std::stable_sort(array, array + N);
+  assert(std::is_sorted(array, array + N));
+  // test swap ranges 2 pattern
+  std::swap_ranges(array, array + N / 2, array + N / 2);
+  std::stable_sort(array, array + N);
+  assert(std::is_sorted(array, array + N));
+  // test reverse swap ranges 2 pattern
+  std::reverse(array, array + N);
+  std::swap_ranges(array, array + N / 2, array + N / 2);
+  std::stable_sort(array, array + N);
+  assert(std::is_sorted(array, array + N));
 }
 
 template <int N>
@@ -185,16 +137,16 @@ TEST_CONSTEXPR_CXX26 void test_larger_sorts() {
   test_larger_sorts<N, N>();
 }
 
-int main(int, char**) {
-  { // test null range
-    int d = 0;
-    std::stable_sort(&d, &d);
+TEST_CONSTEXPR_CXX26 void test() {
+  // test null range
+  int d = 0;
+  std::stable_sort(&d, &d);
+
+  // exhaustively test all possibilities up to length 8
 #if TEST_STD_VER >= 26
-    static_assert((std::stable_sort(&d, &d), true));
+  if !consteval
 #endif
-  }
-
-  { // exhaustively test all possibilities up to length 8
+  {
     test_sort_<1>();
     test_sort_<2>();
     test_sort_<3>();
@@ -205,30 +157,35 @@ int main(int, char**) {
     test_sort_<8>();
   }
 
-  { // larger sorts
-    // run- and compile-time tests
-    test_larger_sorts<256>();
-    test_larger_sorts<257>();
+  test_larger_sorts<256>();
+  test_larger_sorts<257>();
+  test_larger_sorts<499>();
+  test_larger_sorts<500>();
+  test_larger_sorts<997>();
 #if TEST_STD_VER >= 26
-    static_assert((test_larger_sorts<256>(), true));
-    static_assert((test_larger_sorts<257>(), true));
+  if !consteval // only runtime tests bc. error: "constexpr evaluation hit maximum step limit"
 #endif
-
-    // only runtime tests bc. error: "constexpr evaluation hit maximum step limit"
-    test_larger_sorts<499>();
-    test_larger_sorts<500>();
-    test_larger_sorts<997>();
+  {
     test_larger_sorts<1000>();
     test_larger_sorts<1009>();
   }
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+#  if TEST_STD_VER >= 26
+  if !consteval
+#  endif
   { // check that the algorithm works without memory
     std::vector<int> vec(150, 3);
     getGlobalMemCounter()->throw_after = 0;
     std::stable_sort(vec.begin(), vec.end());
   }
-#endif
+#endif // !defined(TEST_HAS_NO_EXCEPTIONS)
+}
 
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 26
+  static_assert((test(), true));
+#endif
   return 0;
 }