Break up tests

Author: elsteveogrande

libcxx/test/std/diagnostics/stacktrace/basic.cmp/equality.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++23
+
+/*
+  (19.6.4.4) Comparisons [stacktrace.basic.cmp]
+
+  template<class Allocator2>
+  friend bool operator==(const basic_stacktrace& x,
+                          const basic_stacktrace<Allocator2>& y) noexcept;
+*/
+
+#include <cassert>
+#include <stacktrace>
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test1() { return std::stacktrace::current(); }
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test2a() { return test1(); }
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test2b() { return test1(); }
+
+_LIBCPP_NO_TAIL_CALLS
+int main(int, char**) {
+  auto st1a = test1(); // [test1, main, ...]
+  assert(st1a == st1a);
+
+  auto st1b = st1a;
+  assert(st1a == st1b);
+
+  auto st2a = test2a(); // [test1, test2a, main, ...]
+  assert(st1a != st2a);
+
+  std::stacktrace empty; // []
+  assert(st1a != empty);
+  assert(st2a != empty);
+
+  assert(st2a.size() > st1a.size());
+  assert(st1a.size() > empty.size());
+
+  auto st2b = test2b(); // [test1, test2b, main, ...]
+  assert(st2a.size() == st2b.size());
+  assert(st2a != st2b);
+
+  return 0;
+}

libcxx/test/std/diagnostics/stacktrace/basic.cmp.pass.cpp renamed to libcxx/test/std/diagnostics/stacktrace/basic.cmp/strong_ordering.cpp

@@ -8,22 +8,17 @@
 
 // REQUIRES: std-at-least-c++23
 
-#include <stacktrace>
-
-#include <cassert>
-
 /*
   (19.6.4.4) Comparisons [stacktrace.basic.cmp]
 
-  template<class Allocator2>
-  friend bool operator==(const basic_stacktrace& x,
-                          const basic_stacktrace<Allocator2>& y) noexcept;
-
   template<class Allocator2>
   friend strong_ordering operator<=>(const basic_stacktrace& x,
                                       const basic_stacktrace<Allocator2>& y) noexcept;
 */
 
+#include <cassert>
+#include <stacktrace>
+
 _LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test1() { return std::stacktrace::current(); }
 
 _LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test2a() { return test1(); }
@@ -33,39 +28,19 @@ _LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::stacktrace test2b() { return test1()
 _LIBCPP_NO_TAIL_CALLS
 int main(int, char**) {
   /*    
-    template<class Allocator2>
-    friend bool operator==(const basic_stacktrace& x, const basic_stacktrace<Allocator2>& y) noexcept;
-    Returns: equal(x.begin(), x.end(), y.begin(), y.end()).
+    Returns: x.size() <=> y.size() if x.size() != y.size();
+    lexicographical_compare_three_way(x.begin(), x.end(), y.begin(), y.end()) otherwise.
   */
-  auto st1a = test1(); // [test1, main, ...]
-  assert(st1a == st1a);
 
+  auto st1a = test1(); // [test1, main, ...]
   auto st1b = st1a;
   assert(st1a == st1b);
-
   auto st2a = test2a(); // [test1, test2a, main, ...]
   assert(st1a != st2a);
-
   std::stacktrace empty; // []
-  assert(st1a != empty);
-  assert(st2a != empty);
-
-  assert(st2a.size() > st1a.size());
-  assert(st1a.size() > empty.size());
-
-  auto st2b = test2b(); // [test1, test2b, main, ...]
-  assert(st2a.size() == st2b.size());
+  auto st2b = test2b();  // [test1, test2b, main, ...]
   assert(st2a != st2b);
 
-  /*    
-    template<class Allocator2>
-    friend strong_ordering
-    operator<=>(const basic_stacktrace& x, const basic_stacktrace<Allocator2>& y) noexcept;
-
-    Returns: x.size() <=> y.size() if x.size() != y.size();
-    lexicographical_compare_three_way(x.begin(), x.end(), y.begin(), y.end()) otherwise.
-  */
-
   // empty:  []
   // st1a:   [test1, main, ...]
   // st1b:   [test1, main, ...] (copy of st1a)

libcxx/test/std/diagnostics/stacktrace/basic.cons/copy_and_move.cpp

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++23
+// ADDITIONAL_COMPILE_FLAGS: -g
+
+/*
+  (19.6.4.2)
+
+  // [stacktrace.basic.cons], creation and assignment
+  basic_stacktrace(const basic_stacktrace& other);
+  basic_stacktrace(basic_stacktrace&& other) noexcept;                                    
+  basic_stacktrace(const basic_stacktrace& other, const allocator_type& alloc);           
+  basic_stacktrace(basic_stacktrace&& other, const allocator_type& alloc);                
+  basic_stacktrace& operator=(const basic_stacktrace& other);                             
+  basic_stacktrace& operator=(basic_stacktrace&& other)
+    noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+      allocator_traits<Allocator>::is_always_equal::value);                               
+*/
+
+#include <cassert>
+#include <stacktrace>
+
+// clang-format off
+uint32_t test1_line;
+uint32_t test2_line;
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE
+std::basic_stacktrace<A> test1(A& alloc) {
+  test1_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret = std::basic_stacktrace<A>::current(alloc);
+  return ret;
+}
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE
+std::basic_stacktrace<A> test2(A& alloc) {
+  test2_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret = test1(alloc);
+  return ret;
+}
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE void test_copy_move_ctors() {
+  using A = std::allocator<std::stacktrace_entry>;
+  A alloc;
+  auto st = std::basic_stacktrace<A>::current(alloc);
+
+  auto copy_constr = std::basic_stacktrace<A>(st);
+  assert(st == copy_constr);
+
+  std::basic_stacktrace<A> copy_assign;
+  copy_assign = std::basic_stacktrace<A>(st);
+  assert(st == copy_assign);
+
+  auto st2 = test2(alloc);
+  assert(st2.size());
+  std::basic_stacktrace<A> move_constr(std::move(st2));
+  assert(move_constr.size());
+  assert(!st2.size());
+
+  auto st3 = test2(alloc);
+  assert(st3.size());
+  std::basic_stacktrace<A> move_assign;
+  move_assign = std::move(st3);
+  assert(move_assign.size());
+  assert(!st3.size());
+
+  // TODO(stacktrace23): should we add test cases with `select_on_container_copy_construction`?
+}
+
+_LIBCPP_NO_TAIL_CALLS
+int main(int, char**) {
+  test_copy_move_ctors();
+  return 0;
+}

libcxx/test/std/diagnostics/stacktrace/basic.cons/ctor_no_args.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++23
+// ADDITIONAL_COMPILE_FLAGS: -g
+
+/*
+  (19.6.4.2)
+
+  // [stacktrace.basic.cons], creation and assignment
+  basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
+*/
+
+#include <cassert>
+#include <stacktrace>
+
+uint32_t test1_line;
+uint32_t test2_line;
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::basic_stacktrace<A> test1(A& alloc) {
+  test1_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret   = std::basic_stacktrace<A>::current(alloc);
+  return ret;
+}
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::basic_stacktrace<A> test2(A& alloc) {
+  test2_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret   = test1(alloc);
+  return ret;
+}
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE void test_default_construct() {
+  std::stacktrace st;
+  assert(st.empty());
+}
+
+_LIBCPP_NO_TAIL_CALLS
+int main(int, char**) {
+  test_default_construct();
+  return 0;
+}

libcxx/test/std/diagnostics/stacktrace/basic.cons/ctor_with_alloc.cpp

@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++23
+// ADDITIONAL_COMPILE_FLAGS: -g
+
+/*
+  (19.6.4.2)
+
+  // [stacktrace.basic.cons], creation and assignment
+  explicit basic_stacktrace(const allocator_type& alloc) noexcept;
+*/
+
+#include <cassert>
+#include <stacktrace>
+
+uint32_t test1_line;
+uint32_t test2_line;
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::basic_stacktrace<A> test1(A& alloc) {
+  test1_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret   = std::basic_stacktrace<A>::current(alloc);
+  return ret;
+}
+
+template <class A>
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE std::basic_stacktrace<A> test2(A& alloc) {
+  test2_line = __LINE__ + 1; // add 1 to get the next line (where the call to `current` occurs)
+  auto ret   = test1(alloc);
+  return ret;
+}
+
+template <typename T>
+struct test_alloc {
+  using size_type     = size_t;
+  using value_type    = T;
+  using pointer       = T*;
+  using const_pointer = T const*;
+
+  template <typename U>
+  struct rebind {
+    using other = test_alloc<U>;
+  };
+
+  std::allocator<T> wrapped_{};
+
+  test_alloc() = default;
+
+  template <typename U>
+  test_alloc(test_alloc<U> const& rhs) : wrapped_(rhs.wrapped_) {}
+
+  bool operator==(auto const& rhs) const { return &rhs == this; }
+  bool operator==(test_alloc const&) const { return true; }
+
+  T* allocate(size_t n) { return wrapped_.allocate(n); }
+  auto allocate_at_least(size_t n) { return wrapped_.allocate_at_least(n); }
+  void deallocate(T* ptr, size_t n) { return wrapped_.deallocate(ptr, n); }
+};
+
+_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE void test_construct_with_allocator() {
+  test_alloc<std::stacktrace_entry> alloc;
+  std::basic_stacktrace<decltype(alloc)> st(alloc);
+  assert(st.empty());
+
+  st = std::basic_stacktrace<decltype(alloc)>::current(alloc);
+  assert(!st.empty());
+}
+
+_LIBCPP_NO_TAIL_CALLS
+int main(int, char**) {
+  test_construct_with_allocator();
+  return 0;
+}