simple.cpp

Go to the documentation of this file.

#include "kblib/simple.h"
#include "catch.hpp"
#include "kblib/stats.h"
 
template <typename>
struct print;
 
TEST_CASE("enumerate") {
   std::vector<unsigned long long> persistent{0, 1, 1, 2, 3, 5, 8};
   SECTION("lvalue") {
      for (auto t : kblib::enumerate(persistent)) {
         auto& v = std::get<0>(t);
         auto i = static_cast<int>(std::get<1>(t));
         REQUIRE(v == kblib::fibonacci(i));
      }
   }
   SECTION("const lvalue") {
      const auto& cp = persistent;
      for (auto t : kblib::enumerate(cp)) {
         auto& v = std::get<0>(t);
         auto i = static_cast<int>(std::get<1>(t));
         REQUIRE(v == kblib::fibonacci(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("iterators") {
      for (auto t : kblib::enumerate(persistent.cbegin(), persistent.cend())) {
         auto& v = std::get<0>(t);
         auto i = static_cast<int>(std::get<1>(t));
         REQUIRE(v == kblib::fibonacci(i));
      }
   }
   SECTION("mutable iterators") {
      std::vector<int> range{0, 1, 2, 3, 4, 5, 6, 7};
      for (auto t : kblib::enumerate(range.begin(), range.end())) {
         auto& v = std::get<0>(t);
         [[gnu::unused]] auto& i = std::get<1>(t);
         v = 0;
      }
      REQUIRE(std::all_of(range.begin(), range.end(),
                          [](int v) { return v == 0; }));
   }
   SECTION("reverse iterators") {
      std::vector<std::size_t> reversed{7, 6, 5, 4, 3, 2, 1, 0};
      for (auto t : kblib::enumerate(reversed.rbegin(), reversed.rend())) {
         auto& v = std::get<0>(t);
         auto& i = std::get<1>(t);
         REQUIRE(v == i);
      }
   }
 
   SECTION("temporary") {
      for (auto t : kblib::enumerate(
               std::vector<unsigned long long>{0, 1, 1, 2, 3, 5, 8})) {
         auto& v = std::get<0>(t);
         auto i = static_cast<int>(std::get<1>(t));
         REQUIRE(v == kblib::fibonacci(i));
      }
   }
   SECTION("vector<bool>") {
      for (auto t : kblib::enumerate(
               std::vector<bool>{false, true, false, true, false})) {
         auto& v = std::get<0>(t);
         auto& i = std::get<1>(t);
         REQUIRE(v == i % 2);
         // print<decltype(v)>{};
      }
   }
}
 
TEST_CASE("safe_auto") {
   {
      KBLIB_UNUSED decltype(auto) dangling = kblib::min(1, 2);
      static_assert(std::is_same<decltype(dangling), int&&>::value, "");
   }
   {
      KBLIB_UNUSED decltype(auto) safe = kblib::safe_auto(kblib::min(1, 2));
      static_assert(std::is_same<decltype(safe), int>::value, "");
   }
}