libstdc++-v3/testsuite/std/ranges/adaptors/join.cc

   1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-options "-std=gnu++2a" }
  19 // { dg-do run { target c++2a } }
  20
  21 #include <algorithm>
  22 #include <array>
  23 #include <ranges>
  24 #include <sstream>
  25 #include <string>
  26 #include <string_view>
  27 #include <vector>
  28 #include <testsuite_hooks.h>
  29 #include <testsuite_iterators.h>
  30
  31 namespace ranges = std::ranges;
  32 namespace views = std::ranges::views;
  33
  34 void
  35 test01()
  36 {
  37   using namespace std::literals;
  38   std::string_view cs[] = {"the", "quick", "brown", "fox"};
  39   auto v = cs | views::join;
  40   VERIFY( ranges::equal(v, "thequickbrownfox"sv) );
  41   using R = decltype(v);
  42   static_assert(ranges::bidirectional_range<R>);
  43   static_assert(ranges::bidirectional_range<const R>);
  44   static_assert(ranges::common_range<R>);
  45   static_assert(ranges::common_range<const R>);
  46 }
  47
  48 void
  49 test02()
  50 {
  51   auto v = (views::iota(0,4)
  52             | views::transform([] (int i) { return views::iota(0,i); })
  53             | views::join);
  54   VERIFY( ranges::equal(v, (int[]){0,0,1,0,1,2}) );
  55   using R = decltype(v);
  56   static_assert(ranges::input_range<R>);
  57   static_assert(!ranges::range<const R>);
  58   static_assert(!ranges::forward_range<R>);
  59   static_assert(!ranges::common_range<const R>);
  60 }
  61
  62 void
  63 test03()
  64 {
  65   auto v = (views::iota(0,4)
  66             | views::transform([] (int i) { return views::iota(0,i); })
  67             | views::filter([] (auto) { return true; })
  68             | views::join);
  69   VERIFY( ranges::equal(v, (int[]){0,0,1,0,1,2}) );
  70   using R = decltype(v);
  71   static_assert(ranges::input_range<R>);
  72   static_assert(!ranges::range<const R>);
  73   static_assert(!ranges::forward_range<R>);
  74   static_assert(!ranges::common_range<const R>);
  75 }
  76
  77 void
  78 test04()
  79 {
  80   auto v = (views::iota(0,4)
  81             | views::transform([] (int i) { return views::iota(0,i); }));
  82   auto v2 = ranges::ref_view{v};
  83   VERIFY( ranges::equal(v2 | views::join, (int[]){0,0,1,0,1,2}) );
  84   using R = decltype(v2);
  85   static_assert(ranges::random_access_range<R>);
  86   static_assert(ranges::range<const R>);
  87   static_assert(ranges::common_range<const R>);
  88   static_assert(ranges::random_access_range<ranges::range_reference_t<R>>);
  89   static_assert(!std::is_reference_v<ranges::range_reference_t<R>>);
  90 }
  91
  92 void
  93 test05()
  94 {
  95   using namespace std::literals;
  96   std::vector<std::string> x = {"the", " ", "quick", " ", "brown", " ", "fox"};
  97   auto v = x | views::join | views::lazy_split(' ');
  98   auto i = v.begin();
  99   VERIFY( ranges::equal(*i++, "the"sv) );
 100   VERIFY( ranges::equal(*i++, "quick"sv) );
 101   VERIFY( ranges::equal(*i++, "brown"sv) );
 102   VERIFY( ranges::equal(*i++, "fox"sv) );
 103   VERIFY( i == v.end() );
 104 }
 105
 106 void
 107 test06()
 108 {
 109   std::vector<std::string> x = {""};
 110   auto i = std::counted_iterator(x.begin(), 1);
 111   auto r = ranges::subrange{i, std::default_sentinel};
 112   auto v = r | views::transform(std::identity{}) | views::join;
 113
 114   // Verify that _Iterator<false> is implicitly convertible to _Iterator<true>.
 115   static_assert(!std::same_as<decltype(ranges::begin(v)),
 116                               decltype(ranges::cbegin(v))>);
 117   auto a = ranges::cbegin(v);
 118   a = ranges::begin(v);
 119
 120   // Verify that _Sentinel<false> is implicitly convertible to _Sentinel<true>.
 121   static_assert(!ranges::common_range<decltype(v)>);
 122   static_assert(!std::same_as<decltype(ranges::end(v)),
 123                               decltype(ranges::cend(v))>);
 124   auto b = ranges::cend(v);
 125   b = ranges::end(v);
 126 }
 127
 128 void
 129 test07()
 130 {
 131   // LWG 3474. Nesting join_views is broken because of CTAD
 132   std::vector<std::vector<std::vector<int>>> nested_vectors = {
 133     {{1, 2, 3}, {4, 5}, {6}},
 134     {{7},       {8, 9}, {10, 11, 12}},
 135     {{13}}
 136   };
 137   auto joined = nested_vectors | std::views::join | std::views::join;
 138
 139   using V = decltype(joined);
 140   static_assert( std::same_as<std::ranges::range_value_t<V>, int> );
 141 }
 142
 143 void
 144 test08()
 145 {
 146   // LWG 3500. join_view::iterator::operator->() is bogus
 147   struct X { int a; };
 148   ranges::single_view<ranges::single_view<X>> s{std::in_place, std::in_place, 5};
 149   auto v = s | views::join;
 150   auto i = v.begin();
 151   VERIFY( i->a == 5 );
 152 }
 153
 154 template<auto join = views::join>
 155 void
 156 test09()
 157 {
 158   // Verify SFINAE behavior.
 159   static_assert(!requires { join(); });
 160   static_assert(!requires { join(0, 0); });
 161   static_assert(!requires { join(0); });
 162   static_assert(!requires { 0 | join; });
 163 }
 164
 165 void
 166 test10()
 167 {
 168   // PR libstdc++/100290
 169   auto v = views::single(0)
 170     | views::transform([](const auto& s) { return views::single(s); })
 171     | views::join;
 172   VERIFY( ranges::next(v.begin()) == v.end() );
 173 }
 174
 175 void
 176 test11()
 177 {
 178   // Verify P2328 changes.
 179   int r[] = {1, 2, 3};
 180   auto v = r
 181     | views::transform([] (int n) { return std::vector{{n, -n}}; })
 182     | views::join;
 183   VERIFY( ranges::equal(v, (int[]){1, -1, 2, -2, 3, -3}) );
 184
 185   struct S {
 186     S() = default;
 187     S(const S&) = delete;
 188     S(S&&) = delete;
 189   };
 190   auto w = r
 191     | views::transform([] (int) { return std::array<S, 2>{}; })
 192     | views::join;
 193   for (auto& i : w)
 194     ;
 195 }
 196
 197 void
 198 test12()
 199 {
 200   // PR libstdc++/101263
 201   constexpr auto b = [] {
 202     auto r = std::views::iota(0, 5)
 203       | std::views::lazy_split(0)
 204       | std::views::join;
 205     return r.begin() != r.end();
 206   }();
 207 }
 208
 209 void
 210 test13()
 211 {
 212   // PR libstdc++/106320
 213   auto l = std::views::transform([](auto x) {
 214     return x | std::views::transform([i=0](auto y) {
 215       return y;
 216     });
 217   });
 218   std::vector<std::vector<int>> v{{5, 6, 7}};
 219   v | l | std::views::join;
 220 }
 221
 222 void
 223 test14()
 224 {
 225   // LWG 3569: join_view fails to support ranges of ranges with
 226   // non-default_initializable iterators
 227   auto ss = std::istringstream{"1 2 3"};
 228   auto v = views::single(views::istream<int>(ss));
 229   using inner = ranges::range_reference_t<decltype(v)>;
 230   static_assert(ranges::input_range<inner>
 231                 && !ranges::forward_range<inner>
 232                 && !std::default_initializable<ranges::iterator_t<inner>>);
 233   VERIFY( ranges::equal(v | views::join, (int[]){1, 2, 3}) );
 234 }
 235
 236 int
 237 main()
 238 {
 239   test01();
 240   test02();
 241   test03();
 242   test04();
 243   test05();
 244   test06();
 245   test07();
 246   test08();
 247   test09();
 248   test10();
 249   test11();
 250   test12();
 251   test13();
 252   test14();
 253 }