libstdc++-v3/testsuite/std/ranges/repeat/1.cc

   1 // { dg-do run { target c++23 } }
   2
   3 #include <ranges>
   4 #include <algorithm>
   5 #include <testsuite_hooks.h>
   6
   7 #if __cpp_lib_ranges_repeat != 202207L
   8 # error "Feature-test macro __cpp_lib_ranges_repeat has wrong value in <ranges>"
   9 #endif
  10
  11 namespace ranges = std::ranges;
  12 namespace views = std::views;
  13
  14 constexpr bool
  15 test01()
  16 {
  17   auto v = views::repeat(42);
  18   static_assert(ranges::random_access_range<decltype(v)>
  19                 && !ranges::sized_range<decltype(v)>);
  20   auto i = ranges::begin(v);
  21   auto s = ranges::end(v);
  22   VERIFY( *i == 42 );
  23   VERIFY( i[0] == 42 );
  24   VERIFY( &i[0] == &i[1] );
  25   VERIFY( &*i == &*(i+1) );
  26   VERIFY( i != s );
  27   auto j = i + 5, k = i + 12;
  28   VERIFY( k - i == 12 );
  29   VERIFY( k - j == 7 );
  30   VERIFY( i - j == -5 );
  31   VERIFY( k > j );
  32   VERIFY( j < k );
  33   VERIFY( i + 5 == j );
  34   VERIFY( i != j );
  35   VERIFY( i + 5 <= j );
  36   VERIFY( j - 5 >= i );
  37
  38   return true;
  39 }
  40
  41 constexpr bool
  42 test02()
  43 {
  44   constexpr int bound = 20;
  45   auto v = views::repeat(42, bound);
  46   static_assert(ranges::random_access_range<decltype(v)>
  47                 && ranges::sized_range<decltype(v)>);
  48   VERIFY( ranges::equal(v, views::repeat(42) | views::take(bound)) );
  49   auto i = ranges::begin(v);
  50   auto s = ranges::end(v);
  51   VERIFY( *i == 42 );
  52   VERIFY( i[0] == 42 );
  53   VERIFY( &i[0] == &i[1] );
  54   VERIFY( &*i == &*(i+1) );
  55   VERIFY( i != s );
  56   auto j = i + 5, k = i + 12;
  57   VERIFY( k - i == 12 );
  58   VERIFY( k - j == 7 );
  59   VERIFY( i - j == -5 );
  60   VERIFY( k > j );
  61   VERIFY( j < k );
  62   VERIFY( i + 5 == j );
  63   VERIFY( i != j );
  64   VERIFY( i + 5 <= j );
  65   VERIFY( j - 5 >= i );
  66
  67   VERIFY( ranges::size(v) == bound );
  68   VERIFY( s - i == bound );
  69   VERIFY( s - j == bound - (j - i) );
  70   VERIFY( i + bound == s );
  71   VERIFY( bound + i == s );
  72
  73   return true;
  74 }
  75
  76 constexpr bool
  77 test03()
  78 {
  79   struct A { int n, m; };
  80   auto v = ranges::repeat_view<A, unsigned>(std::piecewise_construct,
  81                                             std::tuple{1, 2},
  82                                             std::tuple{3});
  83   VERIFY( v[0].n == 1 );
  84   VERIFY( v[0].m == 2 );
  85   VERIFY( ranges::size(v) == 3 );
  86
  87   return true;
  88 }
  89
  90 constexpr bool
  91 test04()
  92 {
  93   // Verify P2474R2 changes to views::take/drop.
  94   auto r = views::repeat(42);
  95
  96   auto rt = r | views::take(10);
  97   static_assert(views::__detail::__is_repeat_view<decltype(rt)>);
  98   VERIFY( ranges::equal(rt, views::repeat(42, 10)) );
  99
 100   auto rd = r | views::drop(10);
 101   static_assert(std::same_as<decltype(rd), decltype(r)>);
 102
 103   auto br = views::repeat(42, 37);
 104
 105   auto brt = br | views::take(10);
 106   static_assert(std::same_as<decltype(brt), decltype(br)>);
 107   VERIFY( ranges::equal(brt, views::repeat(42, 10)) );
 108
 109   auto brt100 = br | views::take(100);
 110   VERIFY( ranges::equal(brt100, br) );
 111
 112   auto brd = br | views::drop(10);
 113   static_assert(std::same_as<decltype(brd), decltype(br)>);
 114   VERIFY( ranges::equal(brd, views::repeat(42, 27)) );
 115
 116   auto brd100 = br | views::drop(100);
 117   VERIFY( ranges::empty(brd100) );
 118
 119   return true;
 120 }
 121
 122 void
 123 test05()
 124 {
 125   // LWG 3796
 126   ranges::repeat_view<int> r;
 127 }
 128
 129 void
 130 test06()
 131 {
 132   struct move_only {
 133     move_only() { }
 134     move_only(move_only&&) { }
 135   };
 136   // P2494R2 Relaxing range adaptors to allow for move only types
 137   static_assert( requires { views::repeat(move_only{}, 2); } );
 138 }
 139
 140 int
 141 main()
 142 {
 143   static_assert(test01());
 144   static_assert(test02());
 145   static_assert(test03());
 146   static_assert(test04());
 147   test05();
 148   test06();
 149 }