[libc++][test] Avoid non-Standard zero-length arrays

libcxx/test/libcxx/gdb/gdb_pretty_printer_test.py

@@ -76,7 +76,7 @@ def invoke(self, arg, from_tty):
         except RuntimeError as e:
             # At this point, lots of different things could be wrong, so don't try to
             # recover or figure it out. Don't exit either, because then it's
-            # impossible debug the framework itself.
+            # impossible to debug the framework itself.
             print("FAIL: Something is wrong in the test framework.")
             print(str(e))
             test_failures += 1

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

@@ -17,6 +17,7 @@
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 
 #include "test_macros.h"
@@ -26,18 +27,18 @@ template <class Iter>
 void
 test_with_iterator()
 {
-    int empty[] = {};
-    std::random_shuffle(Iter(empty), Iter(empty));
+  std::array<int, 0> empty = {};
+  std::random_shuffle(Iter(empty.data()), Iter(empty.data()));
 
-    const int all_elements[] = {1, 2, 3, 4};
-    int           shuffled[] = {1, 2, 3, 4};
-    const unsigned size = sizeof(all_elements)/sizeof(all_elements[0]);
+  const int all_elements[] = {1, 2, 3, 4};
+  int shuffled[]           = {1, 2, 3, 4};
+  const unsigned size      = sizeof(all_elements) / sizeof(all_elements[0]);
 
-    std::random_shuffle(Iter(shuffled), Iter(shuffled+size));
-    assert(std::is_permutation(shuffled, shuffled+size, all_elements));
+  std::random_shuffle(Iter(shuffled), Iter(shuffled + size));
+  assert(std::is_permutation(shuffled, shuffled + size, all_elements));
 
-    std::random_shuffle(Iter(shuffled), Iter(shuffled+size));
-    assert(std::is_permutation(shuffled, shuffled+size, all_elements));
+  std::random_shuffle(Iter(shuffled), Iter(shuffled + size));
+  assert(std::is_permutation(shuffled, shuffled + size, all_elements));
 }
 
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/ranges.transform.binary.iterator.pass.cpp

@@ -89,41 +89,41 @@ constexpr bool test_iterators() {
   }
 
   { // first range empty
-    int a[] = {};
+    std::array<int, 0> a = {};
     int b[] = {5, 4, 3, 2, 1};
     int c[5];
 
     auto ret = std::ranges::transform(
-        In1(a), Sent1(In1(a)), In2(b), Sent2(In2(b + 5)), Out(c), [](int i, int j) { return i + j; });
+        In1(a.data()), Sent1(In1(a.data())), In2(b), Sent2(In2(b + 5)), Out(c), [](int i, int j) { return i + j; });
 
-    assert(base(ret.in1) == a);
+    assert(base(ret.in1) == a.data());
     assert(base(ret.in2) == b);
     assert(base(ret.out) == c);
   }
 
   { // second range empty
     int a[] = {5, 4, 3, 2, 1};
-    int b[] = {};
+    std::array<int, 0> b = {};
     int c[5];
 
     auto ret = std::ranges::transform(
-        In1(a), Sent1(In1(a + 5)), In2(b), Sent2(In2(b)), Out(c), [](int i, int j) { return i + j; });
+        In1(a), Sent1(In1(a + 5)), In2(b.data()), Sent2(In2(b.data())), Out(c), [](int i, int j) { return i + j; });
 
     assert(base(ret.in1) == a);
-    assert(base(ret.in2) == b);
+    assert(base(ret.in2) == b.data());
     assert(base(ret.out) == c);
   }
 
   { // both ranges empty
-    int a[] = {};
-    int b[] = {};
+    std::array<int, 0> a = {};
+    std::array<int, 0> b = {};
     int c[5];
 
     auto ret = std::ranges::transform(
-        In1(a), Sent1(In1(a)), In2(b), Sent2(In2(b)), Out(c), [](int i, int j) { return i + j; });
+        In1(a.data()), Sent1(In1(a.data())), In2(b.data()), Sent2(In2(b.data())), Out(c), [](int i, int j) { return i + j; });
 
-    assert(base(ret.in1) == a);
-    assert(base(ret.in2) == b);
+    assert(base(ret.in1) == a.data());
+    assert(base(ret.in2) == b.data());
     assert(base(ret.out) == c);
   }
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/ranges.transform.binary.range.pass.cpp

@@ -92,47 +92,47 @@ constexpr bool test_iterators() {
   }
 
   { // first range empty
-    int a[] = {};
+    std::array<int, 0> a = {};
     int b[] = {5, 4, 3, 2, 1};
     int c[5];
 
-    auto range1 = std::ranges::subrange(In1(a), Sent1(In1(a)));
+    auto range1 = std::ranges::subrange(In1(a.data()), Sent1(In1(a.data())));
     auto range2 = std::ranges::subrange(In2(b), Sent2(In2(b + 5)));
 
     auto ret = std::ranges::transform(range1, range2, Out(c), [](int i, int j) { return i + j; });
 
-    assert(base(ret.in1) == a);
+    assert(base(ret.in1) == a.data());
     assert(base(ret.in2) == b);
     assert(base(ret.out) == c);
   }
 
   { // second range empty
     int a[] = {5, 4, 3, 2, 1};
-    int b[] = {};
+    std::array<int, 0> b = {};
     int c[5];
 
     auto range1 = std::ranges::subrange(In1(a), Sent1(In1(a + 5)));
-    auto range2 = std::ranges::subrange(In2(b), Sent2(In2(b)));
+    auto range2 = std::ranges::subrange(In2(b.data()), Sent2(In2(b.data())));
 
     auto ret = std::ranges::transform(range1, range2, Out(c), [](int i, int j) { return i + j; });
 
     assert(base(ret.in1) == a);
-    assert(base(ret.in2) == b);
+    assert(base(ret.in2) == b.data());
     assert(base(ret.out) == c);
   }
 
   { // both ranges empty
-    int a[] = {};
-    int b[] = {};
+    std::array<int, 0> a = {};
+    std::array<int, 0> b = {};
     int c[5];
 
-    auto range1 = std::ranges::subrange(In1(a), Sent1(In1(a)));
-    auto range2 = std::ranges::subrange(In2(b), Sent2(In2(b)));
+    auto range1 = std::ranges::subrange(In1(a.data()), Sent1(In1(a.data())));
+    auto range2 = std::ranges::subrange(In2(b.data()), Sent2(In2(b.data())));
 
     auto ret = std::ranges::transform(range1, range2, Out(c), [](int i, int j) { return i + j; });
 
-    assert(base(ret.in1) == a);
-    assert(base(ret.in2) == b);
+    assert(base(ret.in1) == a.data());
+    assert(base(ret.in2) == b.data());
     assert(base(ret.out) == c);
   }
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/ranges.transform.unary.pass.cpp

@@ -108,19 +108,19 @@ constexpr bool test_iterators() {
 
   { // first range empty
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int b[5];
-      auto ret = std::ranges::transform(In1(a), Sent1(In1(a)), Out(b), [](int i) { return i * 2; });
-      assert(base(ret.in) == a);
+      auto ret = std::ranges::transform(In1(a.data()), Sent1(In1(a.data())), Out(b), [](int i) { return i * 2; });
+      assert(base(ret.in) == a.data());
       assert(base(ret.out) == b);
     }
 
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int b[5];
-      auto range = std::ranges::subrange(In1(a), Sent1(In1(a)));
+      auto range = std::ranges::subrange(In1(a.data()), Sent1(In1(a.data())));
       auto ret = std::ranges::transform(range, Out(b), [](int i) { return i * 2; });
-      assert(base(ret.in) == a);
+      assert(base(ret.in) == a.data());
       assert(base(ret.out) == b);
     }
   }

libcxx/test/std/algorithms/alg.nonmodifying/alg.ends_with/ranges.ends_with.pass.cpp

@@ -156,9 +156,9 @@ constexpr void test_iterators() {
 
  { // suffix has zero length
    int a[] = {1, 2, 3, 4, 5, 6};
-   int p[] = {};
+   std::array<int, 0> p = {};
    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
+   auto suffix  = std::ranges::subrange(Iter2(p.data()), Sent2(Iter2(p.data())));
    {
      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
      assert(ret);
@@ -170,9 +170,9 @@ constexpr void test_iterators() {
  }
 
  { // range has zero length
-   int a[] = {};
+   std::array<int, 0> a = {};
    int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
-   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
+   auto whole = std::ranges::subrange(Iter1(a.data()), Sent1(Iter1(a.data())));
    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
    {
      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/ranges.equal.pass.cpp

@@ -23,6 +23,7 @@
 //                                Proj1 proj1 = {}, Proj2 proj2 = {});
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <concepts>
 #include <functional>
@@ -200,32 +201,32 @@ constexpr void test_iterators() {
 
   { // check that two empty ranges work
     {
-      int a[] = {};
-      int b[] = {};
-      auto ret = std::ranges::equal(Iter1(a), Sent1(Iter1(a)), Iter2(b), Sent2(Iter2(b)));
+      std::array<int, 0> a = {};
+      std::array<int, 0> b = {};
+      auto ret = std::ranges::equal(Iter1(a.data()), Sent1(Iter1(a.data())), Iter2(b.data()), Sent2(Iter2(b.data())));
       assert(ret);
     }
     {
-      int a[] = {};
-      int b[] = {};
-      auto range1 = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
-      auto range2 = std::ranges::subrange(Iter2(b), Sent2(Iter2(b)));
+      std::array<int, 0> a = {};
+      std::array<int, 0> b = {};
+      auto range1          = std::ranges::subrange(Iter1(a.data()), Sent1(Iter1(a.data())));
+      auto range2          = std::ranges::subrange(Iter2(b.data()), Sent2(Iter2(b.data())));
       auto ret = std::ranges::equal(range1, range2);
       assert(ret);
     }
   }
 
   { // check that it works with the first range empty
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int b[] = {1, 2};
-      auto ret = std::ranges::equal(Iter1(a), Sent1(Iter1(a)), Iter2(b), Sent2(Iter2(b + 2)));
+      auto ret             = std::ranges::equal(Iter1(a.data()), Sent1(Iter1(a.data())), Iter2(b), Sent2(Iter2(b + 2)));
       assert(!ret);
     }
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int b[] = {1, 2};
-      auto range1 = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
+      auto range1          = std::ranges::subrange(Iter1(a.data()), Sent1(Iter1(a.data())));
       auto range2 = std::ranges::subrange(Iter2(b), Sent2(Iter2(b + 2)));
       auto ret = std::ranges::equal(range1, range2);
       assert(!ret);
@@ -235,15 +236,15 @@ constexpr void test_iterators() {
   { // check that it works with the second range empty
     {
       int a[] = {1, 2};
-      int b[] = {};
-      auto ret = std::ranges::equal(Iter1(a), Sent1(Iter1(a + 2)), Iter2(b), Sent2(Iter2(b)));
+      std::array<int, 0> b = {};
+      auto ret             = std::ranges::equal(Iter1(a), Sent1(Iter1(a + 2)), Iter2(b.data()), Sent2(Iter2(b.data())));
       assert(!ret);
     }
     {
       int a[] = {1, 2};
-      int b[] = {};
+      std::array<int, 0> b = {};
       auto range1 = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 2)));
-      auto range2 = std::ranges::subrange(Iter2(b), Sent2(Iter2(b)));
+      auto range2          = std::ranges::subrange(Iter2(b.data()), Sent2(Iter2(b.data())));
       auto ret = std::ranges::equal(range1, range2);
       assert(!ret);
     }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/ranges.find_end.pass.cpp

@@ -182,16 +182,16 @@ constexpr void test_iterators() {
   { // pattern has zero length
     {
       int a[] = {6, 7, 8};
-      int p[] = {};
-      auto ret = std::ranges::find_end(Iter1(a), Sent1(Iter1(a + 3)), Iter2(p), Sent2(Iter2(p)));
+      std::array<int, 0> p = {};
+      auto ret = std::ranges::find_end(Iter1(a), Sent1(Iter1(a + 3)), Iter2(p.data()), Sent2(Iter2(p.data())));
       assert(base(ret.begin()) == a + 3);
       assert(base(ret.end()) == a + 3);
     }
     {
       int a[] = {6, 7, 8};
-      int p[] = {};
+      std::array<int, 0> p = {};
       auto range1 = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 3)));
-      auto range2 = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
+      auto range2          = std::ranges::subrange(Iter2(p.data()), Sent2(Iter2(p.data())));
       auto ret = std::ranges::find_end(range1, range2);
       assert(base(ret.begin()) == a + 3);
       assert(base(ret.end()) == a + 3);
@@ -200,20 +200,20 @@ constexpr void test_iterators() {
 
   { // range has zero length
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int p[] = {6, 7, 8};
-      auto ret = std::ranges::find_end(Iter1(a), Sent1(Iter1(a)), Iter2(p), Sent2(Iter2(p + 3)));
-      assert(base(ret.begin()) == a);
-      assert(base(ret.end()) == a);
+      auto ret = std::ranges::find_end(Iter1(a.data()), Sent1(Iter1(a.data())), Iter2(p), Sent2(Iter2(p + 3)));
+      assert(base(ret.begin()) == a.data());
+      assert(base(ret.end()) == a.data());
     }
     {
-      int a[] = {};
+      std::array<int, 0> a = {};
       int p[] = {6, 7, 8};
-      auto range1 = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
+      auto range1          = std::ranges::subrange(Iter1(a.data()), Sent1(Iter1(a.data())));
       auto range2 = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
       auto ret = std::ranges::find_end(range1, range2);
-      assert(base(ret.begin()) == a);
-      assert(base(ret.end()) == a);
+      assert(base(ret.begin()) == a.data());
+      assert(base(ret.end()) == a.data());
     }
   }
 

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/ranges.for_each.pass.cpp

@@ -19,6 +19,7 @@
 //     ranges::for_each(R&& r, Fun f, Proj proj = {});
 
 #include <algorithm>
+#include <array>
 #include <ranges>
 
 #include "almost_satisfies_types.h"
@@ -98,12 +99,12 @@ constexpr void test_iterator() {
 
   { // check that an empty range works
     {
-      int a[] = {};
-      std::ranges::for_each(Iter(a), Sent(Iter(a)), [](auto&) { assert(false); });
+      std::array<int, 0> a = {};
+      std::ranges::for_each(Iter(a.data()), Sent(Iter(a.data())), [](auto&) { assert(false); });
     }
     {
-      int a[] = {};
-      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a)));
+      std::array<int, 0> a = {};
+      auto range           = std::ranges::subrange(Iter(a.data()), Sent(Iter(a.data())));
       std::ranges::for_each(range, [](auto&) { assert(false); });
     }
   }

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/ranges.for_each_n.pass.cpp

@@ -16,6 +16,7 @@
 //     ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
 
 #include <algorithm>
+#include <array>
 #include <ranges>
 
 #include "almost_satisfies_types.h"
@@ -58,8 +59,8 @@ constexpr void test_iterator() {
   }
 
   { // check that an empty range works
-    int a[] = {};
-    std::ranges::for_each_n(Iter(a), 0, [](auto&) { assert(false); });
+    std::array<int, 0> a = {};
+    std::ranges::for_each_n(Iter(a.data()), 0, [](auto&) { assert(false); });
   }
 }