based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit 2924ad6155a029964bec66a410983f838e1b38d6
parent fa32c0655ebccdccc6a4e47a88618f87d3ae14fb
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Tue, 1 Apr 2025 10:49:26 +0200

min_element and max_element tests

Diffstat:
M test/CMakeLists.txt | ++
A test/source/max_element_test.cpp | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A test/source/min_element_test.cpp | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3 files changed, 186 insertions(+), 0 deletions(-)

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

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

# ---- Algorithm ----

add_test(min_test)
add_test(min_element_test)
add_test(max_test)
add_test(max_element_test)

# ---- End-of-file commands ----

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

@@ -0,0 +1,92 @@

#include <array>

#include <catch2/catch_test_macros.hpp>

#include "based/algorithm.hpp"

TEST_CASE("max_element(empty)", "[based/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]")
{
std::array arr = {0};
const auto* itr = based::max_element(std::begin(arr), std::end(arr));
const auto idx = std::distance(std::cbegin(arr), itr);
REQUIRE(idx == 0);
}

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,92 @@

#include <array>

#include <catch2/catch_test_macros.hpp>

#include "based/algorithm.hpp"

TEST_CASE("min_element(empty)", "[based/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]")
{
std::array arr = {0};
const auto* itr = based::min_element(std::begin(arr), std::end(arr));
const auto idx = std::distance(std::cbegin(arr), itr);
REQUIRE(idx == 0);
}

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

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

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

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

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

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

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

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

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