based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commitfdf5dc326745b5c66b5d075ce4fd7be4ab0494b2
parent1dea5f5fd7a9beff59d71757ea9ec7ff4bc1af35
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateThu, 3 Apr 2025 13:52:06 +0200

Clenup test tags

Diffstat:
Mtest/source/max_element_test.cpp|+++++++++++-----------
Mtest/source/max_test.cpp|+++++++++++++++++++++++++++++++++---------------------------------
Mtest/source/min_element_test.cpp|+++++++++++-----------
Mtest/source/min_test.cpp|+++++++++++++++++++++++++++++++++---------------------------------
Mtest/source/minmax_element_test.cpp|++++++++++------------

5 files changed, 98 insertions(+), 100 deletions(-)

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

@@ -4,14 +4,14 @@

#include "based/algorithm.hpp"
TEST_CASE("max_element(empty)", "[based/algorithm/max_element]")
TEST_CASE("max_element(empty)", "[algorithm/max_element]")
{
std::array<int, 0> arr = {};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));
REQUIRE(itr == std::end(arr));
}
TEST_CASE("max_element(1)", "[based/algorithm/max_element]")
TEST_CASE("max_element(1)", "[algorithm/max_element]")
{
std::array arr = {0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -19,7 +19,7 @@ TEST_CASE("max_element(1)", "[based/algorithm/max_element]")

REQUIRE(idx == 0);
}
TEST_CASE("max_element(2) = first", "[based/algorithm/max_element]")
TEST_CASE("max_element(2) = first", "[algorithm/max_element]")
{
std::array arr = {1, 0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -27,7 +27,7 @@ TEST_CASE("max_element(2) = first", "[based/algorithm/max_element]")

REQUIRE(idx == 0);
}
TEST_CASE("max_element(2) = second", "[based/algorithm/max_element]")
TEST_CASE("max_element(2) = second", "[algorithm/max_element]")
{
std::array arr = {0, 1};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -35,7 +35,7 @@ TEST_CASE("max_element(2) = second", "[based/algorithm/max_element]")

REQUIRE(idx == 1);
}
TEST_CASE("max_element(2) = stable", "[based/algorithm/max_element]")
TEST_CASE("max_element(2) = stable", "[algorithm/max_element]")
{
std::array arr = {0, 0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -43,7 +43,7 @@ TEST_CASE("max_element(2) = stable", "[based/algorithm/max_element]")

REQUIRE(idx == 1);
}
TEST_CASE("max_element(3) = first", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = first", "[algorithm/max_element]")
{
std::array arr = {2, 1, 0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -51,7 +51,7 @@ TEST_CASE("max_element(3) = first", "[based/algorithm/max_element]")

REQUIRE(idx == 0);
}
TEST_CASE("max_element(3) = second", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = second", "[algorithm/max_element]")
{
std::array arr = {1, 2, 0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -59,7 +59,7 @@ TEST_CASE("max_element(3) = second", "[based/algorithm/max_element]")

REQUIRE(idx == 1);
}
TEST_CASE("max_element(3) = third", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = third", "[algorithm/max_element]")
{
std::array arr = {0, 1, 2};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -67,7 +67,7 @@ TEST_CASE("max_element(3) = third", "[based/algorithm/max_element]")

REQUIRE(idx == 2);
}
TEST_CASE("max_element(3) = stable(1, 2)", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = stable(1, 2)", "[algorithm/max_element]")
{
std::array arr = {1, 1, 0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -75,7 +75,7 @@ TEST_CASE("max_element(3) = stable(1, 2)", "[based/algorithm/max_element]")

REQUIRE(idx == 1);
}
TEST_CASE("max_element(3) = stable(1, 3)", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = stable(1, 3)", "[algorithm/max_element]")
{
std::array arr = {1, 0, 1};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

@@ -83,7 +83,7 @@ TEST_CASE("max_element(3) = stable(1, 3)", "[based/algorithm/max_element]")

REQUIRE(idx == 2);
}
TEST_CASE("max_element(3) = stable(2, 3)", "[based/algorithm/max_element]")
TEST_CASE("max_element(3) = stable(2, 3)", "[algorithm/max_element]")
{
std::array arr = {0, 1, 1};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));

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

@@ -2,47 +2,47 @@

#include "based/algorithm.hpp"
TEST_CASE("max(literal, literal) = right", "[based/algorithm/max]")
TEST_CASE("max(literal, literal) = right", "[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]")
TEST_CASE("max(literal, literal) = left", "[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]")
TEST_CASE("max(value, literal) = right", "[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]")
TEST_CASE("max(value, literal) = left", "[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]")
TEST_CASE("max(literal, value) = right", "[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]")
TEST_CASE("max(literal, value) = left", "[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]")
TEST_CASE("max(value, value) = right", "[algorithm/max]")
{
int a = 3;
int b = 4;

@@ -50,7 +50,7 @@ TEST_CASE("max(value, value) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, value) = left", "[based/algorithm/max]")
TEST_CASE("max(value, value) = left", "[algorithm/max]")
{
int a = 4;
int b = 3;

@@ -58,35 +58,35 @@ TEST_CASE("max(value, value) = left", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, literal) = right", "[based/algorithm/max]")
TEST_CASE("max(const value, literal) = right", "[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]")
TEST_CASE("max(const value, literal) = left", "[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]")
TEST_CASE("max(literal, const value) = right", "[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]")
TEST_CASE("max(literal, const value) = left", "[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]")
TEST_CASE("max(const value, const value) = right", "[algorithm/max]")
{
const int a = 3;
const int b = 4;

@@ -94,7 +94,7 @@ TEST_CASE("max(const value, const value) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, const value) = left", "[based/algorithm/max]")
TEST_CASE("max(const value, const value) = left", "[algorithm/max]")
{
const int a = 4;
const int b = 3;

@@ -102,7 +102,7 @@ TEST_CASE("max(const value, const value) = left", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, const value) = right", "[based/algorithm/max]")
TEST_CASE("max(value, const value) = right", "[algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
const int b = 4;

@@ -110,7 +110,7 @@ TEST_CASE("max(value, const value) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(value, const value) = left", "[based/algorithm/max]")
TEST_CASE("max(value, const value) = left", "[algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
const int b = 3;

@@ -118,7 +118,7 @@ TEST_CASE("max(value, const value) = left", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, value) = right", "[based/algorithm/max]")
TEST_CASE("max(const value, value) = right", "[algorithm/max]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness

@@ -126,7 +126,7 @@ TEST_CASE("max(const value, value) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, b) == 4);
}
TEST_CASE("max(const value, value) = left", "[based/algorithm/max]")
TEST_CASE("max(const value, value) = left", "[algorithm/max]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness

@@ -136,21 +136,21 @@ TEST_CASE("max(const value, value) = left", "[based/algorithm/max]")

// NOLINTBEGIN move-const-arg
TEST_CASE("max(move, literal) = right", "[based/algorithm/max]")
TEST_CASE("max(move, literal) = right", "[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]")
TEST_CASE("max(move, literal) = left", "[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]")
TEST_CASE("max(move, value) = right", "[algorithm/max]")
{
int a = 3;
int b = 4; // NOLINT misc-const-correctness

@@ -158,7 +158,7 @@ TEST_CASE("max(move, value) = right", "[based/algorithm/max]")

REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, value) = left", "[based/algorithm/max]")
TEST_CASE("max(move, value) = left", "[algorithm/max]")
{
int a = 4;
int b = 3; // NOLINT misc-const-correctness

@@ -166,7 +166,7 @@ TEST_CASE("max(move, value) = left", "[based/algorithm/max]")

REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, const value) = right", "[based/algorithm/max]")
TEST_CASE("max(move, const value) = right", "[algorithm/max]")
{
int a = 3;
const int b = 4;

@@ -174,7 +174,7 @@ TEST_CASE("max(move, const value) = right", "[based/algorithm/max]")

REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(move, const value) = left", "[based/algorithm/max]")
TEST_CASE("max(move, const value) = left", "[algorithm/max]")
{
int a = 4;
const int b = 3;

@@ -182,21 +182,21 @@ TEST_CASE("max(move, const value) = left", "[based/algorithm/max]")

REQUIRE(based::max(std::move(a), b) == 4);
}
TEST_CASE("max(literal, move) = right", "[based/algorithm/max]")
TEST_CASE("max(literal, move) = right", "[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]")
TEST_CASE("max(literal, move) = left", "[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]")
TEST_CASE("max(value, move) = right", "[algorithm/max]")
{
int a = 3; // NOLINT misc-const-correctness
int b = 4;

@@ -204,7 +204,7 @@ TEST_CASE("max(value, move) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(value, move) = left", "[based/algorithm/max]")
TEST_CASE("max(value, move) = left", "[algorithm/max]")
{
int a = 4; // NOLINT misc-const-correctness
int b = 3;

@@ -212,7 +212,7 @@ TEST_CASE("max(value, move) = left", "[based/algorithm/max]")

REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(const value, move) = right", "[based/algorithm/max]")
TEST_CASE("max(const value, move) = right", "[algorithm/max]")
{
const int a = 3;
int b = 4;

@@ -220,7 +220,7 @@ TEST_CASE("max(const value, move) = right", "[based/algorithm/max]")

REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(const value, move) = left", "[based/algorithm/max]")
TEST_CASE("max(const value, move) = left", "[algorithm/max]")
{
const int a = 4;
int b = 3;

@@ -228,7 +228,7 @@ TEST_CASE("max(const value, move) = left", "[based/algorithm/max]")

REQUIRE(based::max(a, std::move(b)) == 4);
}
TEST_CASE("max(move, move) = right", "[based/algorithm/max]")
TEST_CASE("max(move, move) = right", "[algorithm/max]")
{
int a = 3;
int b = 4;

@@ -237,7 +237,7 @@ TEST_CASE("max(move, move) = right", "[based/algorithm/max]")

REQUIRE(based::max(std::move(a), std::move(b)) == 4);
}
TEST_CASE("max(move, move) = left", "[based/algorithm/max]")
TEST_CASE("max(move, move) = left", "[algorithm/max]")
{
int a = 4;
int b = 3;

@@ -248,7 +248,7 @@ TEST_CASE("max(move, move) = left", "[based/algorithm/max]")

// NOLINTEND move-const-arg
TEST_CASE("max-stability", "[based/algorithm/max]")
TEST_CASE("max-stability", "[algorithm/max]")
{
using type_t = std::pair<int, int>;

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

@@ -4,14 +4,14 @@

#include "based/algorithm.hpp"
TEST_CASE("min_element(empty)", "[based/algorithm/min_element]")
TEST_CASE("min_element(empty)", "[algorithm/min_element]")
{
std::array<int, 0> arr = {};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));
REQUIRE(itr == std::end(arr));
}
TEST_CASE("min_element(1)", "[based/algorithm/min_element]")
TEST_CASE("min_element(1)", "[algorithm/min_element]")
{
std::array arr = {0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -19,7 +19,7 @@ TEST_CASE("min_element(1)", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(2) = first", "[based/algorithm/min_element]")
TEST_CASE("min_element(2) = first", "[algorithm/min_element]")
{
std::array arr = {0, 1};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -27,7 +27,7 @@ TEST_CASE("min_element(2) = first", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(2) = second", "[based/algorithm/min_element]")
TEST_CASE("min_element(2) = second", "[algorithm/min_element]")
{
std::array arr = {1, 0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -35,7 +35,7 @@ TEST_CASE("min_element(2) = second", "[based/algorithm/min_element]")

REQUIRE(idx == 1);
}
TEST_CASE("min_element(2) = stable", "[based/algorithm/min_element]")
TEST_CASE("min_element(2) = stable", "[algorithm/min_element]")
{
std::array arr = {0, 0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -43,7 +43,7 @@ TEST_CASE("min_element(2) = stable", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(3) = first", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = first", "[algorithm/min_element]")
{
std::array arr = {0, 1, 2};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -51,7 +51,7 @@ TEST_CASE("min_element(3) = first", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(3) = second", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = second", "[algorithm/min_element]")
{
std::array arr = {1, 0, 2};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -59,7 +59,7 @@ TEST_CASE("min_element(3) = second", "[based/algorithm/min_element]")

REQUIRE(idx == 1);
}
TEST_CASE("min_element(3) = third", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = third", "[algorithm/min_element]")
{
std::array arr = {2, 1, 0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -67,7 +67,7 @@ TEST_CASE("min_element(3) = third", "[based/algorithm/min_element]")

REQUIRE(idx == 2);
}
TEST_CASE("min_element(3) = stable(1, 2)", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = stable(1, 2)", "[algorithm/min_element]")
{
std::array arr = {0, 0, 1};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -75,7 +75,7 @@ TEST_CASE("min_element(3) = stable(1, 2)", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(3) = stable(1, 3)", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = stable(1, 3)", "[algorithm/min_element]")
{
std::array arr = {0, 1, 0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

@@ -83,7 +83,7 @@ TEST_CASE("min_element(3) = stable(1, 3)", "[based/algorithm/min_element]")

REQUIRE(idx == 0);
}
TEST_CASE("min_element(3) = stable(2, 3)", "[based/algorithm/min_element]")
TEST_CASE("min_element(3) = stable(2, 3)", "[algorithm/min_element]")
{
std::array arr = {1, 0, 0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));

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

@@ -2,47 +2,47 @@

#include "based/algorithm.hpp"
TEST_CASE("min(literal, literal) = left", "[based/algorithm/min]")
TEST_CASE("min(literal, literal) = left", "[algorithm/min]")
{
REQUIRE(std::same_as<int&&, decltype(based::min(3, 4))>);
REQUIRE(based::min(3, 4) == 3);
}
TEST_CASE("min(literal, literal) = right", "[based/algorithm/min]")
TEST_CASE("min(literal, literal) = right", "[algorithm/min]")
{
REQUIRE(std::same_as<int&&, decltype(based::min(4, 3))>);
REQUIRE(based::min(4, 3) == 3);
}
TEST_CASE("min(value, literal) = left", "[based/algorithm/min]")
TEST_CASE("min(value, literal) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(a, 4))>);
REQUIRE(based::min(a, 4) == 3);
}
TEST_CASE("min(value, literal) = right", "[based/algorithm/min]")
TEST_CASE("min(value, literal) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(a, 3))>);
REQUIRE(based::min(a, 3) == 3);
}
TEST_CASE("min(literal, value) = left", "[based/algorithm/min]")
TEST_CASE("min(literal, value) = left", "[algorithm/min]")
{
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(3, b))>);
REQUIRE(based::min(3, b) == 3);
}
TEST_CASE("min(literal, value) = right", "[based/algorithm/min]")
TEST_CASE("min(literal, value) = right", "[algorithm/min]")
{
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(4, b))>);
REQUIRE(based::min(4, b) == 3);
}
TEST_CASE("min(value, value) = left", "[based/algorithm/min]")
TEST_CASE("min(value, value) = left", "[algorithm/min]")
{
int a = 3;
int b = 4;

@@ -50,7 +50,7 @@ TEST_CASE("min(value, value) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, value) = right", "[based/algorithm/min]")
TEST_CASE("min(value, value) = right", "[algorithm/min]")
{
int a = 4;
int b = 3;

@@ -58,35 +58,35 @@ TEST_CASE("min(value, value) = right", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, literal) = left", "[based/algorithm/min]")
TEST_CASE("min(const value, literal) = left", "[algorithm/min]")
{
const int a = 3;
REQUIRE(std::same_as<int, decltype(based::min(a, 4))>);
REQUIRE(based::min(a, 4) == 3);
}
TEST_CASE("min(const value, literal) = right", "[based/algorithm/min]")
TEST_CASE("min(const value, literal) = right", "[algorithm/min]")
{
const int a = 4;
REQUIRE(std::same_as<int, decltype(based::min(a, 3))>);
REQUIRE(based::min(a, 3) == 3);
}
TEST_CASE("min(literal, const value) = left", "[based/algorithm/min]")
TEST_CASE("min(literal, const value) = left", "[algorithm/min]")
{
const int b = 4;
REQUIRE(std::same_as<int, decltype(based::min(3, b))>);
REQUIRE(based::min(3, b) == 3);
}
TEST_CASE("min(literal, const value) = right", "[based/algorithm/min]")
TEST_CASE("min(literal, const value) = right", "[algorithm/min]")
{
const int b = 3;
REQUIRE(std::same_as<int, decltype(based::min(4, b))>);
REQUIRE(based::min(4, b) == 3);
}
TEST_CASE("min(const value, const value) = left", "[based/algorithm/min]")
TEST_CASE("min(const value, const value) = left", "[algorithm/min]")
{
const int a = 3;
const int b = 4;

@@ -94,7 +94,7 @@ TEST_CASE("min(const value, const value) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, const value) = right", "[based/algorithm/min]")
TEST_CASE("min(const value, const value) = right", "[algorithm/min]")
{
const int a = 4;
const int b = 3;

@@ -102,7 +102,7 @@ TEST_CASE("min(const value, const value) = right", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, const value) = left", "[based/algorithm/min]")
TEST_CASE("min(value, const value) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
const int b = 4;

@@ -110,7 +110,7 @@ TEST_CASE("min(value, const value) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, const value) = right", "[based/algorithm/min]")
TEST_CASE("min(value, const value) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
const int b = 3;

@@ -118,7 +118,7 @@ TEST_CASE("min(value, const value) = right", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, value) = left", "[based/algorithm/min]")
TEST_CASE("min(const value, value) = left", "[algorithm/min]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness

@@ -126,7 +126,7 @@ TEST_CASE("min(const value, value) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, value) = right", "[based/algorithm/min]")
TEST_CASE("min(const value, value) = right", "[algorithm/min]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness

@@ -136,21 +136,21 @@ TEST_CASE("min(const value, value) = right", "[based/algorithm/min]")

// NOLINTBEGIN move-const-arg
TEST_CASE("min(move, literal) = left", "[based/algorithm/min]")
TEST_CASE("min(move, literal) = left", "[algorithm/min]")
{
int a = 3;
REQUIRE(std::same_as<int&&, decltype(based::min(std::move(a), 4))>);
REQUIRE(based::min(std::move(a), 4) == 3);
}
TEST_CASE("min(move, literal) = right", "[based/algorithm/min]")
TEST_CASE("min(move, literal) = right", "[algorithm/min]")
{
int a = 4;
REQUIRE(std::same_as<int&&, decltype(based::min(std::move(a), 3))>);
REQUIRE(based::min(std::move(a), 3) == 3);
}
TEST_CASE("min(move, value) = left", "[based/algorithm/min]")
TEST_CASE("min(move, value) = left", "[algorithm/min]")
{
int a = 3;
int b = 4; // NOLINT misc-const-correctness

@@ -158,7 +158,7 @@ TEST_CASE("min(move, value) = left", "[based/algorithm/min]")

REQUIRE(based::min(std::move(a), b) == 3);
}
TEST_CASE("min(move, value) = right", "[based/algorithm/min]")
TEST_CASE("min(move, value) = right", "[algorithm/min]")
{
int a = 4;
int b = 3; // NOLINT misc-const-correctness

@@ -166,7 +166,7 @@ TEST_CASE("min(move, value) = right", "[based/algorithm/min]")

REQUIRE(based::min(std::move(a), b) == 3);
}
TEST_CASE("min(move, const value) = left", "[based/algorithm/min]")
TEST_CASE("min(move, const value) = left", "[algorithm/min]")
{
int a = 3;
const int b = 4;

@@ -174,7 +174,7 @@ TEST_CASE("min(move, const value) = left", "[based/algorithm/min]")

REQUIRE(based::min(std::move(a), b) == 3);
}
TEST_CASE("min(move, const value) = right", "[based/algorithm/min]")
TEST_CASE("min(move, const value) = right", "[algorithm/min]")
{
int a = 4;
const int b = 3;

@@ -182,21 +182,21 @@ TEST_CASE("min(move, const value) = right", "[based/algorithm/min]")

REQUIRE(based::min(std::move(a), b) == 3);
}
TEST_CASE("min(literal, move) = left", "[based/algorithm/min]")
TEST_CASE("min(literal, move) = left", "[algorithm/min]")
{
int b = 4;
REQUIRE(std::same_as<int&&, decltype(based::min(3, std::move(b)))>);
REQUIRE(based::min(3, std::move(b)) == 3);
}
TEST_CASE("min(literal, move) = right", "[based/algorithm/min]")
TEST_CASE("min(literal, move) = right", "[algorithm/min]")
{
int b = 3;
REQUIRE(std::same_as<int&&, decltype(based::min(4, std::move(b)))>);
REQUIRE(based::min(4, std::move(b)) == 3);
}
TEST_CASE("min(value, move) = left", "[based/algorithm/min]")
TEST_CASE("min(value, move) = left", "[algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
int b = 4;

@@ -204,7 +204,7 @@ TEST_CASE("min(value, move) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, std::move(b)) == 3);
}
TEST_CASE("min(value, move) = right", "[based/algorithm/min]")
TEST_CASE("min(value, move) = right", "[algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
int b = 3;

@@ -212,7 +212,7 @@ TEST_CASE("min(value, move) = right", "[based/algorithm/min]")

REQUIRE(based::min(a, std::move(b)) == 3);
}
TEST_CASE("min(const value, move) = left", "[based/algorithm/min]")
TEST_CASE("min(const value, move) = left", "[algorithm/min]")
{
const int a = 3;
int b = 4;

@@ -220,7 +220,7 @@ TEST_CASE("min(const value, move) = left", "[based/algorithm/min]")

REQUIRE(based::min(a, std::move(b)) == 3);
}
TEST_CASE("min(const value, move) = right", "[based/algorithm/min]")
TEST_CASE("min(const value, move) = right", "[algorithm/min]")
{
const int a = 4;
int b = 3;

@@ -228,7 +228,7 @@ TEST_CASE("min(const value, move) = right", "[based/algorithm/min]")

REQUIRE(based::min(a, std::move(b)) == 3);
}
TEST_CASE("min(move, move) = left", "[based/algorithm/min]")
TEST_CASE("min(move, move) = left", "[algorithm/min]")
{
int a = 3;
int b = 4;

@@ -237,7 +237,7 @@ TEST_CASE("min(move, move) = left", "[based/algorithm/min]")

REQUIRE(based::min(std::move(a), std::move(b)) == 3);
}
TEST_CASE("min(move, move) = right", "[based/algorithm/min]")
TEST_CASE("min(move, move) = right", "[algorithm/min]")
{
int a = 4;
int b = 3;

@@ -248,7 +248,7 @@ TEST_CASE("min(move, move) = right", "[based/algorithm/min]")

// NOLINTEND move-const-arg
TEST_CASE("min-stability", "[based/algorithm/min]")
TEST_CASE("min-stability", "[algorithm/min]")
{
using type_t = std::pair<int, int>;

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

@@ -2,7 +2,7 @@

#include "based/algorithm.hpp"
TEST_CASE("minmax_element(empty)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(empty)", "[algorithm/minmax_element]")
{
std::array<int, 0> arr = {};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -10,7 +10,7 @@ TEST_CASE("minmax_element(empty)", "[based/algorithm/minmax_element]")

REQUIRE(max == std::end(arr));
}
TEST_CASE("minmax_element(1)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(1)", "[algorithm/minmax_element]")
{
std::array arr = {0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -20,7 +20,7 @@ TEST_CASE("minmax_element(1)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(increasing even)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(increasing even)", "[algorithm/minmax_element]")
{
std::array arr = {0, 1, 2, 3};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -30,7 +30,7 @@ TEST_CASE("minmax_element(increasing even)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(increasing odd)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(increasing odd)", "[algorithm/minmax_element]")
{
std::array arr = {0, 1, 2, 3, 4};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -40,7 +40,7 @@ TEST_CASE("minmax_element(increasing odd)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(decreasing even)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(decreasing even)", "[algorithm/minmax_element]")
{
std::array arr = {3, 2, 1, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -50,7 +50,7 @@ TEST_CASE("minmax_element(decreasing even)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(decreasing odd)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(decreasing odd)", "[algorithm/minmax_element]")
{
std::array arr = {4, 3, 2, 1, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -60,7 +60,7 @@ TEST_CASE("minmax_element(decreasing odd)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(stable even)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(stable even)", "[algorithm/minmax_element]")
{
std::array arr = {3, 0, 0, 3};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -70,7 +70,7 @@ TEST_CASE("minmax_element(stable even)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(stable odd)", "[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(stable odd)", "[algorithm/minmax_element]")
{
std::array arr = {3, 0, 3, 3, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -80,8 +80,7 @@ TEST_CASE("minmax_element(stable odd)", "[based/algorithm/minmax_element]")

REQUIRE(maxi == std::size(arr) - 2);
}
TEST_CASE("minmax_element(stable increasing)",
"[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(stable increasing)", "[algorithm/minmax_element]")
{
std::array arr = {0, 0, 1, 2, 3, 4, 4};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));

@@ -91,8 +90,7 @@ TEST_CASE("minmax_element(stable increasing)",

REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(stable decreasing)",
"[based/algorithm/minmax_element]")
TEST_CASE("minmax_element(stable decreasing)", "[algorithm/minmax_element]")
{
std::array arr = {4, 4, 3, 2, 1, 0, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));