Improve tests

Author: ldionne

libcxx/test/std/ranges/range.utility/range.elementsof/ctad.compile.pass.cpp

@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+//
+// template<range R, class Allocator = allocator<byte>>
+// struct std::ranges::elements_of;
+//
+// template<class R, class Allocator = allocator<byte>>
+// elements_of(R&&, Allocator = Allocator()) -> elements_of<R&&, Allocator>;
+
+#include <concepts>
+#include <cstddef>
+#include <memory>
+#include <ranges>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+
+template <class Allocator, class Range>
+constexpr void test_impl() {
+  Range r;
+  Allocator a;
+
+  // With a lvalue range
+  {
+    std::ranges::elements_of elements(r);
+    static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&, std::allocator<std::byte>>>);
+  }
+
+  // With a rvalue range
+  {
+    std::ranges::elements_of elements((Range()));
+    static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&&, std::allocator<std::byte>>>);
+  }
+
+  // With lvalue range and allocator
+  {
+    std::ranges::elements_of elements(r, a);
+    static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&, Allocator>>);
+  }
+
+  // With rvalue range and allocator
+  {
+    std::ranges::elements_of elements((Range()), Allocator());
+    static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&&, Allocator>>);
+  }
+
+  // Ensure we can use designated initializers
+  {
+    // lvalues
+    {
+      std::ranges::elements_of elements{.range = r, .allocator = a};
+      static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&, Allocator>>);
+    }
+
+    // rvalues
+    {
+      std::ranges::elements_of elements{.range = Range(), .allocator = Allocator()};
+      static_assert(std::same_as<decltype(elements), std::ranges::elements_of<Range&&, Allocator>>);
+    }
+  }
+}
+
+template <class Iterator>
+struct Range {
+  Iterator begin() const;
+  sentinel_wrapper<Iterator> end() const;
+};
+
+constexpr bool test() {
+  types::for_each(types::type_list<std::allocator<std::byte>, min_allocator<std::byte>, test_allocator<std::byte>>{},
+                  []<class Allocator> {
+                    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iterator> {
+                      test_impl<Allocator, Range<Iterator>>();
+                    });
+                  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.utility/range.elementsof/ctad.pass.cpp

@@ -8,13 +8,17 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// std::ranges::elements_of;
-
-#include <ranges>
+// <ranges>
+//
+// template<range R, class Allocator = allocator<byte>>
+// struct std::ranges::elements_of;
 
+#include <cassert>
 #include <concepts>
 #include <memory>
+#include <ranges>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "min_allocator.h"
@@ -25,9 +29,9 @@ template <class Iterator>
 struct Range {
   using Sentinel = sentinel_wrapper<Iterator>;
 
-  Iterator begin() { return Iterator(data_.data()); }
+  constexpr Iterator begin() { return Iterator(data_.data()); }
 
-  Sentinel end() { return Sentinel(Iterator(data_.data() + data_.size())); }
+  constexpr Sentinel end() { return Sentinel(Iterator(data_.data() + data_.size())); }
 
 private:
   std::vector<int> data_ = {0, 1, 2, 3};
@@ -40,50 +44,45 @@ constexpr bool test_range() {
   using elements_of_t = std::ranges::elements_of<Range&, Allocator>;
   {
     // constructor
-    std::same_as<elements_of_t> decltype(auto) elements_of                 = std::ranges::elements_of(r, Allocator());
-    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
-    if (!std::is_constant_evaluated()) {
-      assert(std::ranges::distance(elements_of_range) == 4);
-    }
-    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+    std::same_as<elements_of_t> decltype(auto) e = std::ranges::elements_of(r, Allocator());
+    std::same_as<Range&> decltype(auto) range    = e.range;
+    assert(std::ranges::distance(range) == 4);
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) allocator = e.allocator;
   }
   {
     // designated initializer
-    std::same_as<elements_of_t> decltype(auto) elements_of = std::ranges::elements_of{
+    std::same_as<elements_of_t> decltype(auto) e = std::ranges::elements_of{
         .range     = r,
         .allocator = Allocator(),
     };
-    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
-    if (!std::is_constant_evaluated()) {
-      assert(std::ranges::distance(elements_of_range) == 4);
-    }
-    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+    std::same_as<Range&> decltype(auto) range = e.range;
+    assert(&range == &r);
+    assert(std::ranges::distance(range) == 4);
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) allocator = e.allocator;
   }
   {
     // copy constructor
-    std::same_as<elements_of_t> decltype(auto) elements_of_1                 = std::ranges::elements_of(r, Allocator());
-    std::same_as<elements_of_t> auto elements_of_2                           = elements_of_1;
-    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_1_range = elements_of_1.range;
-    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_2_range = elements_of_2.range;
-    if (!std::is_constant_evaluated()) {
-      assert(std::ranges::distance(elements_of_1_range) == 4);
-      assert(std::ranges::distance(elements_of_2_range) == 4);
-    }
-    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+    std::same_as<elements_of_t> decltype(auto) e   = std::ranges::elements_of(r, Allocator());
+    std::same_as<elements_of_t> auto copy          = e;
+    std::same_as<Range&> decltype(auto) range      = e.range;
+    std::same_as<Range&> decltype(auto) copy_range = copy.range;
+    assert(&range == &r);
+    assert(&range == &copy_range);
+    assert(std::ranges::distance(range) == 4);
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) copy_allocator = copy.allocator;
   }
 
   using elements_of_r_t = std::ranges::elements_of<Range&&, Allocator>;
   {
     // move constructor
-    std::same_as<elements_of_r_t> decltype(auto) elements_of_1 = std::ranges::elements_of(std::move(r), Allocator());
-    std::same_as<elements_of_r_t> auto elements_of_2           = std::move(elements_of_1);
-    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_1_range = std::move(elements_of_1.range);
-    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_2_range = std::move(elements_of_2.range);
-    if (!std::is_constant_evaluated()) {
-      assert(std::ranges::distance(elements_of_1_range) == 4);
-      assert(std::ranges::distance(elements_of_2_range) == 4);
-    }
-    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+    std::same_as<elements_of_r_t> decltype(auto) e  = std::ranges::elements_of(std::move(r), Allocator());
+    std::same_as<elements_of_r_t> auto copy         = std::move(e);
+    std::same_as<Range&&> decltype(auto) range      = std::move(e.range);
+    std::same_as<Range&&> decltype(auto) copy_range = std::move(copy.range);
+    assert(&range == &r);
+    assert(&range == &copy_range);
+    assert(std::ranges::distance(range) == 4);
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) copy_allocator = copy.allocator;
   }
   return true;
 }