based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit1dea5f5fd7a9beff59d71757ea9ec7ff4bc1af35
parent568d6f0f23754354e684fef61c27466bb74fcc43
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateWed, 2 Apr 2025 21:27:08 +0200

Minmax_element test

Diffstat:
Mtest/CMakeLists.txt|+
Atest/source/minmax_element_test.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2 files changed, 104 insertions(+), 0 deletions(-)

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

@@ -26,6 +26,7 @@ add_test(min_test)

add_test(min_element_test)
add_test(max_test)
add_test(max_element_test)
add_test(minmax_element_test)
# ---- End-of-file commands ----

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

@@ -0,0 +1,103 @@

#include <catch2/catch_test_macros.hpp>
#include "based/algorithm.hpp"
TEST_CASE("minmax_element(empty)", "[based/algorithm/minmax_element]")
{
std::array<int, 0> arr = {};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
REQUIRE(min == std::end(arr));
REQUIRE(max == std::end(arr));
}
TEST_CASE("minmax_element(1)", "[based/algorithm/minmax_element]")
{
std::array arr = {0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 0);
REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(increasing even)", "[based/algorithm/minmax_element]")
{
std::array arr = {0, 1, 2, 3};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 0);
REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(increasing odd)", "[based/algorithm/minmax_element]")
{
std::array arr = {0, 1, 2, 3, 4};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 0);
REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(decreasing even)", "[based/algorithm/minmax_element]")
{
std::array arr = {3, 2, 1, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == std::size(arr) - 1);
REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(decreasing odd)", "[based/algorithm/minmax_element]")
{
std::array arr = {4, 3, 2, 1, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == std::size(arr) - 1);
REQUIRE(maxi == 0);
}
TEST_CASE("minmax_element(stable even)", "[based/algorithm/minmax_element]")
{
std::array arr = {3, 0, 0, 3};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 1);
REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(stable odd)", "[based/algorithm/minmax_element]")
{
std::array arr = {3, 0, 3, 3, 0};
const auto [min, max] = based::minmax_element(std::begin(arr), std::end(arr));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 1);
REQUIRE(maxi == std::size(arr) - 2);
}
TEST_CASE("minmax_element(stable increasing)",
"[based/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));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == 0);
REQUIRE(maxi == std::size(arr) - 1);
}
TEST_CASE("minmax_element(stable decreasing)",
"[based/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));
const auto mini = std::distance(std::begin(arr), min);
const auto maxi = std::distance(std::begin(arr), max);
REQUIRE(mini == std::size(arr) - 2);
REQUIRE(maxi == 1);
}