libstdc++-v3/testsuite/23_containers/vector/cons/from_range.cc

   1 // { dg-do run { target c++23 } }
   2
   3 #include <vector>
   4 #include <span>
   5 #include <testsuite_hooks.h>
   6 #include <testsuite_iterators.h>
   7 #include <testsuite_allocator.h>
   8
   9 void
  10 test_deduction_guide(long* p)
  11 {
  12   __gnu_test::test_input_range<long> r(p, p);
  13   std::vector v(std::from_range, r);
  14   static_assert(std::is_same_v<decltype(v), std::vector<long>>);
  15
  16   using Alloc = __gnu_test::SimpleAllocator<long>;
  17   Alloc alloc;
  18   std::vector v2(std::from_range, r, alloc);
  19   static_assert(std::is_same_v<decltype(v2), std::vector<long, Alloc>>);
  20 }
  21
  22 template<typename Range, typename Alloc>
  23 constexpr void
  24 do_test(Alloc alloc)
  25 {
  26   // The vector's value_type.
  27   using V = typename std::allocator_traits<Alloc>::value_type;
  28
  29   // The range's value_type.
  30   using T = std::ranges::range_value_t<Range>;
  31   T a[]{1,2,3,4,5,6,7,8,9};
  32
  33   auto eq = [](const std::vector<V, Alloc>& l, std::span<T> r) {
  34     if (l.size() != r.size())
  35       return false;
  36     for (auto i = 0u; i < l.size(); ++i)
  37       if (l[i] != r[i])
  38         return false;
  39     return true;
  40   };
  41
  42   std::vector<V, Alloc> v0(std::from_range, Range(a, a+0));
  43   VERIFY( v0.empty() );
  44   VERIFY( v0.get_allocator() == Alloc() );
  45
  46   std::vector<V, Alloc> v4(std::from_range, Range(a, a+4));
  47   VERIFY( eq(v4, {a, 4}) );
  48   VERIFY( v4.get_allocator() == Alloc() );
  49
  50   std::vector<V, Alloc> v9(std::from_range, Range(a, a+9), alloc);
  51   VERIFY( eq(v9, {a, 9}) );
  52   VERIFY( v9.get_allocator() == alloc );
  53 }
  54
  55 template<typename Range>
  56 void
  57 do_test_a()
  58 {
  59   do_test<Range>(std::allocator<int>());
  60   do_test<Range>(__gnu_test::uneq_allocator<int>(42));
  61 }
  62
  63 bool
  64 test_ranges()
  65 {
  66   using namespace __gnu_test;
  67
  68   do_test_a<test_forward_range<int>>();
  69   do_test_a<test_forward_sized_range<int>>();
  70   do_test_a<test_sized_range_sized_sent<int, forward_iterator_wrapper>>();
  71
  72   do_test_a<test_input_range<int>>();
  73   do_test_a<test_input_sized_range<int>>();
  74   do_test_a<test_sized_range_sized_sent<int, input_iterator_wrapper>>();
  75
  76   do_test_a<test_range<int, input_iterator_wrapper_nocopy>>();
  77   do_test_a<test_sized_range<int, input_iterator_wrapper_nocopy>>();
  78   do_test_a<test_sized_range_sized_sent<int, input_iterator_wrapper_nocopy>>();
  79
  80   do_test_a<test_forward_range<short>>();
  81   do_test_a<test_input_range<short>>();
  82
  83   // Not lvalue-convertible to int
  84   struct C {
  85     C(int v) : val(v) { }
  86     operator int() && { return val; }
  87     bool operator==(int b) const { return b == val; }
  88     int val;
  89   };
  90   using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>;
  91   do_test<rvalue_input_range>(std::allocator<int>());
  92
  93   return true;
  94 }
  95
  96 constexpr bool
  97 test_constexpr()
  98 {
  99   // XXX: this doesn't test the non-forward_range code paths are constexpr.
 100   do_test<std::span<short>>(std::allocator<int>());
 101   return true;
 102 }
 103
 104 int main()
 105 {
 106   test_ranges();
 107   static_assert( test_constexpr() );
 108 }