iterators.cpp

Go to the documentation of this file.

#include "kblib/iterators.h"
#include "kblib/build.h"
 
#include "catch.hpp"
 
#include <iterator>
#include <list>
#include <set>
#include <sstream>
 
TEST_CASE("to_pointer") {
   auto smart_ptr = std::make_unique<int>(0);
   auto* raw_pointer = kblib::to_pointer(smart_ptr);
   CHECK(raw_pointer == smart_ptr.get());
   const auto& smart_ptr_const_ref = smart_ptr;
   auto* raw_pointer2 = kblib::to_pointer(smart_ptr_const_ref);
   CHECK(raw_pointer2 == smart_ptr_const_ref.get());
}
 
TEST_CASE("range") {
   // range supports iterators and other similar types.
   std::vector<int> v(100);
   CHECK(v.begin() == *kblib::range(v.begin(), v.end()).begin());
   CHECK(v.end() == *kblib::range(v.begin(), v.end()).end());
 
   std::vector<int> r{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   auto r2 = kblib::range(10);
   CHECK(r.size() == r2.size());
   CHECK(std::equal(r.begin(), r.end(), r2.begin()));
   CHECK(r2[0] == 0);
   CHECK(r2[9] == 9);
   CHECK(r2[-1] == -1);
   SECTION("size") {
      CHECK(kblib::range(0, 10, 1).size() == 10);
      CHECK(kblib::range(10).size() == 10);
      CHECK(kblib::range(0, 10, 2).size() == 5);
      CHECK(kblib::range(0, 1).size() == 1);
      CHECK(kblib::range(0, 0).size() == 0);
      CHECK(kblib::range(0, 0, 1).size() == 0);
 
      CHECK(kblib::range(10, 20, 1).size() == 10);
      CHECK(kblib::range(10, 20, 2).size() == 5);
      CHECK(kblib::range(10, 11).size() == 1);
      CHECK(kblib::range(10, 10).size() == 0);
      CHECK(kblib::range(10, 10, 1).size() == 0);
   }
   SECTION("empty") {
      CHECK(kblib::range(0, 0, 1).empty());
      CHECK(kblib::range(0, 0, 2).empty());
      CHECK(kblib::range(10, 10).empty());
 
      CHECK(not kblib::range(0, 10, 1).empty());
      CHECK(not kblib::range(0, 10, 2).empty());
   }
}
 
TEST_CASE("range conversion") {
   SECTION("vector") {
      auto r = kblib::range(2, 5);
      auto v = std::vector<int>(r);
      CHECK(v.size() == r.size());
      CHECK(std::equal(v.begin(), v.end(), r.begin()));
   }
   SECTION("string") {
      auto r = kblib::range(+'a', 'z' + 1);
      auto v = std::string(r);
      CHECK(v == "abcdefghijklmnopqrstuvwxyz");
      CHECK(v.size() == r.size());
      CHECK(std::equal(v.begin(), v.end(), r.begin()));
   }
   auto x = std::set<int>(kblib::range(0, 10));
}
 
TEST_CASE("range comparison") {
   auto equal = [](auto r1, auto r2) {
      auto r1b = r1.begin();
      auto r1e = r1.end();
      auto r2b = r2.begin();
      auto r2e = r2.end();
      return std::distance(r1b, r1e) == std::distance(r2b, r2e)
             and kblib::equal(r1b, r1e, r2b);
   };
 
   SECTION("equivalency") {
 
      auto target10 = std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
      auto target10m = std::vector<int>{0, -1, -2, -3, -4, -5, -6, -7, -8, -9};
      auto target10r = std::vector<int>{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
 
      CHECK(equal(kblib::range(0, 10), target10));
      CHECK(equal(kblib::range(10), target10));
      CHECK(equal(kblib::range(0, 10, kblib::incrementer{}), target10));
 
      CHECK(equal(kblib::range(0, 10, 2), std::vector<int>{0, 2, 4, 6, 8}));
 
      CHECK(equal(kblib::range(10, 0, -1), target10r));
      CHECK(equal(kblib::range(10, 0, kblib::decrementer{}), target10r));
 
      CHECK(equal(kblib::range(0, -10, -1), target10m));
      CHECK(equal(kblib::range(0, -10), target10m));
 
      CHECK(equal(kblib::range(0, 11, 2), kblib::range(0, 12, 2)));
   }
 
   SECTION("comparisons") {
 
      CHECK(kblib::range(0, 0, 1) == kblib::range(1, 1, 2));
      CHECK(kblib::range(100, 100, 1) == kblib::range(0, 0, 2));
      CHECK(kblib::range(0, 10) != kblib::range(10, 0));
      CHECK(kblib::range(0, 11, 2) != kblib::range(0, 10, 2));
      CHECK(kblib::range(0, 0, 1) != kblib::range(0, 1, 2));
   }
 
   SECTION("buildiota equivalency") {
      auto l = kblib::buildiota<std::list<int>>(10u, 10, -1);
      CHECK(equal(kblib::range(10, 0, -1), l));
   }
}
 
TEST_CASE("range from iterators") {
   std::string str = "abcdefghijklmnopqrstuvwxyz";
   // Just asserting that this loop compiles.
   for ([[gnu::unused]] std::string::iterator c :
        kblib::range(str.begin(), str.end())) {
   }
}
 
TEST_CASE("ranges overflow") {
   unsigned char c{};
   for (auto i : kblib::range(static_cast<unsigned char>(255))) {
      c = i;
   }
   CHECK(c == 254);
}
 
#if KBLIB_USE_CXX17
 
TEST_CASE("magic_enumerate") {
   std::vector<int> persistent{0, 1, 1, 2, 3, 5, 8};
   SECTION("lvalue") {
      for (auto&& [i, v] : kblib::magic_enumerate(persistent)) {
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("non-forwarding lvalue") {
      for (auto& [i, v] : kblib::magic_enumerate(persistent)) {
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("copy") {
      for (auto [i, v] : kblib::magic_enumerate(persistent)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
      }
   }
 
   SECTION("const lvalue") {
      const auto& cp = persistent;
      for (auto&& [i, v] : kblib::magic_enumerate(cp)) {
         REQUIRE(&v == &cp[i]);
         static_assert(std::is_const_v<std::remove_reference_t<decltype(v)>>,
                       "v must refer to const when the range is const");
      }
   }
   SECTION("const reference") {
      for (const auto& [i, v] : kblib::magic_enumerate(persistent)) {
         REQUIRE(&v == &persistent[i]);
         static_assert(
             std::is_const_v<std::remove_reference_t<decltype(v)>>,
             "v must refer to const when the bound reference is const");
      }
   }
   SECTION("copy from const") {
      const auto& cp = persistent;
      for (auto [i, v] : kblib::magic_enumerate(cp)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
         static_assert(
             not std::is_const_v<std::remove_reference_t<decltype(v)>>,
             "v must not be const when copied from a const range");
      }
   }
   SECTION("const copy from non-const") {
#  if defined(__clang__)
      // Suppress warning for intentional behavior
#     pragma clang diagnostic push
#     pragma clang diagnostic ignored "-Wrange-loop-analysis"
#  endif
      for (const auto [i, v] : kblib::magic_enumerate(persistent)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
         static_assert(std::is_const_v<std::remove_reference_t<decltype(v)>>,
                       "v must refer to const in a const copy");
      }
#  if defined(__clang__)
#     pragma clang diagnostic pop
#  endif
   }
 
   SECTION("iterators") {
      for (auto&& [i, v] :
           kblib::magic_enumerate(persistent.cbegin(), persistent.cend())) {
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("mutable iterators") {
      std::vector<int> range{0, 1, 2, 3, 4, 5, 6, 7};
      for (auto&& [i, v] : kblib::magic_enumerate(range.begin(), range.end())) {
         v = 0;
      }
      REQUIRE(std::all_of(range.begin(), range.end(),
                          [](int v) { return v == 0; }));
   }
   SECTION("reverse iterators") {
      std::vector<int> reversed{7, 6, 5, 4, 3, 2, 1, 0};
      int last = -1;
      for (auto&& [i, v] :
           kblib::magic_enumerate(reversed.rbegin(), reversed.rend())) {
         REQUIRE(v == static_cast<int>(i));
         ++v;
         last = v;
      }
      REQUIRE(last == reversed.front());
   }
 
   SECTION("temporary") {
      for (auto&& [i, v] :
           kblib::magic_enumerate(std::vector<int>(persistent))) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
      }
   }
   SECTION("input iterators") {
      std::istringstream is{"0 0 1 1 2 2 3 3 4 4 5 5 6 6"};
      for (auto&& [i, v] : kblib::magic_enumerate(
               std::istream_iterator<int>(is), std::istream_iterator<int>())) {
         REQUIRE(v == static_cast<int>(i) / 2);
      }
   }
   SECTION("copied input iterators") {
      std::istringstream is{"0 0 1 1 2 2 3 3 4 4 5 5 6 6"};
      for (auto [i, v] : kblib::magic_enumerate(std::istream_iterator<int>(is),
                                                std::istream_iterator<int>())) {
         REQUIRE(v == static_cast<int>(i) / 2);
      }
   }
 
   SECTION("move-only") {
      std::vector<std::unique_ptr<int>> ptr_vec(10);
      for ([[maybe_unused]] auto&& [i, ptr] : kblib::magic_enumerate(ptr_vec)) {
         REQUIRE(not ptr);
      }
   }
 
   SECTION("array") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto [i, v] : kblib::magic_enumerate(arr)) {
         REQUIRE(&arr[i] != &v);
         REQUIRE(static_cast<int>(i) == v);
         REQUIRE(arr[i] == v);
         ++v;
         REQUIRE(arr[i] != v);
      }
   }
 
   SECTION("array by ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto& [i, v] : kblib::magic_enumerate(arr)) {
         REQUIRE(&arr[i] == &v);
      }
   }
 
   SECTION("array by const ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (const auto& [i, v] : kblib::magic_enumerate(arr)) {
         REQUIRE(&arr[i] == &v);
      }
   }
 
   SECTION("array by forwarding ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto&& [i, v] : kblib::magic_enumerate(arr)) {
         REQUIRE(&arr[i] == &v);
      }
   }
}
 
TEST_CASE("cry_enumerate") {
   std::vector<int> persistent{0, 1, 1, 2, 3, 5, 8};
   SECTION("lvalue") {
      for (auto&& [i, v] : kblib::cry_enumerate(persistent)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("non-forwarding lvalue") {
      for (auto& [i, v] : kblib::cry_enumerate(persistent)) {
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("copy") {
      for (auto [i, v] : kblib::cry_enumerate(persistent)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
      }
   }
 
   SECTION("const lvalue") {
      const auto& cp = persistent;
      for (auto&& [i, v] : kblib::cry_enumerate(cp)) {
         REQUIRE(&v == &cp[i]);
         static_assert(
             std::is_const<
                 typename std::remove_reference<decltype(v)>::type>::value,
             "v must refer to const when the range is const");
      }
   }
   SECTION("const reference") {
      for (const auto& [i, v] : kblib::cry_enumerate(persistent)) {
         REQUIRE(&v == &persistent[i]);
         static_assert(
             std::is_const<
                 typename std::remove_reference<decltype(v)>::type>::value,
             "v must refer to const when the bound reference is const");
      }
   }
   SECTION("copy from const") {
      const auto& cp = persistent;
      for (auto [i, v] : kblib::cry_enumerate(cp)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
         // This approach can't do this
         /*static_assert(
             not std::is_const<
                 typename std::remove_reference<decltype(v)>::type>::value,
             "v must not be const when copied from a const range");*/
      }
   }
   SECTION("const copy from non-const") {
#  if defined(__clang__)
      // Suppress warning for intentional behavior
#     pragma clang diagnostic push
#     pragma clang diagnostic ignored "-Wrange-loop-analysis"
#  endif
      for (const auto [i, v] : kblib::cry_enumerate(persistent)) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
         static_assert(
             std::is_const<
                 typename std::remove_reference<decltype(v)>::type>::value,
             "v must refer to const in a const copy");
      }
#  if defined(__clang__)
#     pragma clang diagnostic pop
#  endif
   }
 
   SECTION("iterators") {
      for (auto&& [i, v] :
           kblib::cry_enumerate(persistent.cbegin(), persistent.cend())) {
         REQUIRE(&v == &persistent[i]);
      }
   }
   SECTION("mutable iterators") {
      std::vector<int> range{0, 1, 2, 3, 4, 5, 6, 7};
      for (auto&& [i, v] : kblib::cry_enumerate(range.begin(), range.end())) {
         v = 0;
      }
      REQUIRE(std::all_of(range.begin(), range.end(),
                          [](int v) { return v == 0; }));
   }
   SECTION("reverse iterators") {
      std::vector<int> reversed{7, 6, 5, 4, 3, 2, 1, 0};
      for (auto&& [i, v] :
           kblib::cry_enumerate(reversed.rbegin(), reversed.rend())) {
         REQUIRE(v == static_cast<int>(i));
      }
   }
 
   SECTION("temporary") {
      for (auto&& [i, v] : kblib::cry_enumerate(std::vector<int>(persistent))) {
         REQUIRE(v == persistent[i]);
         REQUIRE(&v != &persistent[i]);
      }
   }
   SECTION("input iterators") {
      std::istringstream is{"0 0 1 1 2 2 3 3 4 4 5 5 6 6"};
      for (auto&& [i, v] : kblib::cry_enumerate(std::istream_iterator<int>(is),
                                                std::istream_iterator<int>())) {
         REQUIRE(v == static_cast<int>(i) / 2);
      }
   }
   SECTION("copied input iterators") {
      std::istringstream is{"0 0 1 1 2 2 3 3 4 4 5 5 6 6"};
      for (auto [i, v] : kblib::cry_enumerate(std::istream_iterator<int>(is),
                                              std::istream_iterator<int>())) {
         REQUIRE(v == static_cast<int>(i) / 2);
      }
   }
 
   SECTION("move-only") {
      std::vector<std::unique_ptr<int>> ptr_vec(10);
      for (auto&& [i, ptr] : kblib::cry_enumerate(ptr_vec)) {
         (void)i;
      }
   }
 
   SECTION("array") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto [i, v] : kblib::cry_enumerate(arr)) {
         REQUIRE(static_cast<int>(i) == v);
      }
   }
 
   SECTION("array by ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto& [i, v] : kblib::cry_enumerate(arr)) {
         REQUIRE(static_cast<int>(i) == v);
      }
   }
 
   SECTION("array by const ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (const auto& [i, v] : kblib::cry_enumerate(arr)) {
         REQUIRE(static_cast<int>(i) == v);
      }
   }
 
   SECTION("array by forwarding ref") {
      int arr[5] = {0, 1, 2, 3, 4};
      for (auto&& [i, v] : kblib::cry_enumerate(arr)) {
         REQUIRE(static_cast<int>(i) == v);
      }
   }
}
 
#endif