based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
commitb532664244ab0b6c5ba6bf872a1526da2b5af1c7
parente54f14fb4c935942ff2124c5e90fb92a228fd6d4
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateMon, 31 Mar 2025 14:56:09 +0200

Fix max and test thoroughly

Diffstat:
Minclude/based/algorithm.hpp|+++++++++------
Mtest/CMakeLists.txt|+
Atest/source/max_test.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3 files changed, 273 insertions(+), 6 deletions(-)

diff --git a/include/based/algorithm.hpp b/include/based/algorithm.hpp

@@ -50,16 +50,19 @@ I min_element(I first, I last)

}
// returns max element, second if equal
template<Relation R>
const domain_t<R>& max(const domain_t<R>& lhs, const domain_t<R>& rhs, R r)
template<Relation R, BareRegular T, BareRegular U>
requires BareSameAs<T, U> && BareSameAs<T, domain_t<R>>
decltype(auto) max(T&& lhs, U&& rhs, R r)
{
return r(rhs, lhs) ? lhs : rhs;
return r(rhs, lhs) ? std::forward<T>(lhs) : std::forward<U>(rhs);
}
template<Regular T>
const T& max(const T& lhs, const T& rhs)
template<BareRegular T, BareRegular U>
requires BareSameAs<T, U>
decltype(auto) max(T&& lhs, U&& rhs)
{
return based::max(lhs, rhs, std::less<T>());
return based::max(
std::forward<T>(lhs), std::forward<U>(rhs), std::less<bare_t<T>>());
}
// return last max element

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt

@@ -23,6 +23,7 @@ endfunction()

# ---- Algorithm ----
add_test(min_test)
add_test(max_test)
# ---- End-of-file commands ----

diff --git a/test/source/max_test.cpp b/test/source/max_test.cpp

@@ -0,0 +1,263 @@

#include <catch2/catch_test_macros.hpp>
#include "based/algorithm.hpp"
TEST_CASE("max(literal, literal) = right", "[based/algorithm/max]")
{
REQUIRE(std::same_as<int&&, decltype(based::max(3, 4))>);
REQUIRE(based::max(3, 4) == 4);
}
TEST_CASE("max(literal, literal) = left", "[based/algorithm/max]")
{
REQUIRE(std::same_as<int&&, decltype(based::max(4, 3))>);
REQUIRE(based::max(4, 3) == 4);
}
TEST_CASE("max(value, literal) = right", "[based/algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(a, 4))>);
REQUIRE(based::max(a, 4) == 4);
}
TEST_CASE("max(value, literal) = left", "[based/algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(a, 3))>);
REQUIRE(based::max(a, 3) == 4);
}
TEST_CASE("max(literal, value) = right", "[based/algorithm/max]")
{
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(3, b))>);
REQUIRE(based::max(3, b) == 4);
}
TEST_CASE("max(literal, value) = left", "[based/algorithm/max]")
{
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(4, b))>);
REQUIRE(based::max(4, b) == 4);
}
TEST_CASE("max(value, value) = right", "[based/algorithm/max]")
{
int a = 3;
int b = 4;
REQUIRE(std::same_as<int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, value) = left", "[based/algorithm/max]")
{
int a = 4;
int b = 3;
REQUIRE(std::same_as<int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, literal) = right", "[based/algorithm/max]")
{
const int a = 3;
REQUIRE(std::same_as<int, decltype(based::max(a, 4))>);
REQUIRE(based::max(a, 4) == 4);
}
TEST_CASE("max(const value, literal) = left", "[based/algorithm/max]")
{
const int a = 4;
REQUIRE(std::same_as<int, decltype(based::max(a, 3))>);
REQUIRE(based::max(a, 3) == 4);
}
TEST_CASE("max(literal, const value) = right", "[based/algorithm/max]")
{
const int b = 4;
REQUIRE(std::same_as<int, decltype(based::max(3, b))>);
REQUIRE(based::max(3, b) == 4);
}
TEST_CASE("max(literal, const value) = left", "[based/algorithm/max]")
{
const int b = 3;
REQUIRE(std::same_as<int, decltype(based::max(4, b))>);
REQUIRE(based::max(4, b) == 4);
}
TEST_CASE("max(const value, const value) = right", "[based/algorithm/max]")
{
const int a = 3;
const int b = 4;
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, const value) = left", "[based/algorithm/max]")
{
const int a = 4;
const int b = 3;
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, const value) = right", "[based/algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
const int b = 4;
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, const value) = left", "[based/algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
const int b = 3;
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, value) = right", "[based/algorithm/max]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, value) = left", "[based/algorithm/max]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<const int&, decltype(based::max(a, b))>);
REQUIRE(based::max(a, b) == 4);
}
// NOLINTBEGIN move-const-arg
TEST_CASE("max(move, literal) = right", "[based/algorithm/max]")
{
int a = 3;
REQUIRE(std::same_as<int&&, decltype(based::max(std::move(a), 4))>);
REQUIRE(based::max(std::move(a), 4) == 4);
}
TEST_CASE("max(move, literal) = left", "[based/algorithm/max]")
{
int a = 4;
REQUIRE(std::same_as<int&&, decltype(based::max(std::move(a), 3))>);
REQUIRE(based::max(std::move(a), 3) == 4);
}
TEST_CASE("max(move, value) = right", "[based/algorithm/max]")
{
int a = 3;
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(std::move(a), b))>);
REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, value) = left", "[based/algorithm/max]")
{
int a = 4;
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::max(std::move(a), b))>);
REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, const value) = right", "[based/algorithm/max]")
{
int a = 3;
const int b = 4;
REQUIRE(std::same_as<int, decltype(based::max(std::move(a), b))>);
REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, const value) = left", "[based/algorithm/max]")
{
int a = 4;
const int b = 3;
REQUIRE(std::same_as<int, decltype(based::max(std::move(a), b))>);
REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(literal, move) = right", "[based/algorithm/max]")
{
int b = 4;
REQUIRE(std::same_as<int&&, decltype(based::max(3, std::move(b)))>);
REQUIRE(based::max(3, std::move(b)) == 4);
}
TEST_CASE("max(literal, move) = left", "[based/algorithm/max]")
{
int b = 3;
REQUIRE(std::same_as<int&&, decltype(based::max(4, std::move(b)))>);
REQUIRE(based::max(4, std::move(b)) == 4);
}
TEST_CASE("max(value, move) = right", "[based/algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
int b = 4;
REQUIRE(std::same_as<int, decltype(based::max(a, std::move(b)))>);
REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(value, move) = left", "[based/algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
int b = 3;
REQUIRE(std::same_as<int, decltype(based::max(a, std::move(b)))>);
REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(const value, move) = right", "[based/algorithm/max]")
{
const int a = 3;
int b = 4;
REQUIRE(std::same_as<int, decltype(based::max(a, std::move(b)))>);
REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(const value, move) = left", "[based/algorithm/max]")
{
const int a = 4;
int b = 3;
REQUIRE(std::same_as<int, decltype(based::max(a, std::move(b)))>);
REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(move, move) = right", "[based/algorithm/max]")
{
int a = 3;
int b = 4;
REQUIRE(
std::same_as<int&&, decltype(based::max(std::move(a), std::move(b)))>);
REQUIRE(based::max(std::move(a), std::move(b)) == 4);
}
TEST_CASE("max(move, move) = left", "[based/algorithm/max]")
{
int a = 4;
int b = 3;
REQUIRE(
std::same_as<int&&, decltype(based::max(std::move(a), std::move(b)))>);
REQUIRE(based::max(std::move(a), std::move(b)) == 4);
}
// NOLINTEND move-const-arg
TEST_CASE("max-stability", "[based/algorithm/max]")
{
using type_t = std::pair<int, int>;
static const auto cmp = [](const type_t& x, const type_t& y)
{ return x.first < y.first; };
const type_t a = {3, 4};
const type_t b = {3, 5};
REQUIRE(based::max(a, b, cmp).second == 5);
REQUIRE(based::max(b, a, cmp).second == 4);
}