coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added tests for is_heap and sort_heap

Browse Source
This commit is contained in:
Roland Reichwein 2026-03-08 22:07:15 +01:00
parent 3a5291463f
commit 4925d00746
1 changed files with 221 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
test/test_algorithm.cpp
View File

@ -1377,6 +1377,227 @@ namespace
CHECK(isEqual);
}
//*************************************************************************
TEST(is_heap_default_true)
{
std::vector<int> data = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
std::make_heap(data.begin(), data.end());
bool expected = std::is_heap(data.begin(), data.end());
bool result = etl::is_heap(data.begin(), data.end());
CHECK_EQUAL(expected, result);
CHECK(result);
}
//*************************************************************************
TEST(is_heap_default_false)
{
std::vector<int> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
bool expected = std::is_heap(data.begin(), data.end());
bool result = etl::is_heap(data.begin(), data.end());
CHECK_EQUAL(expected, result);
CHECK(!result);
}
//*************************************************************************
TEST(is_heap_compare_true)
{
std::vector<int> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
std::make_heap(data.begin(), data.end(), Greater());
bool expected = std::is_heap(data.begin(), data.end(), Greater());
bool result = etl::is_heap(data.begin(), data.end(), Greater());
CHECK_EQUAL(expected, result);
CHECK(result);
}
//*************************************************************************
TEST(is_heap_compare_false)
{
std::vector<int> data = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
bool expected = std::is_heap(data.begin(), data.end(), Greater());
bool result = etl::is_heap(data.begin(), data.end(), Greater());
CHECK_EQUAL(expected, result);
CHECK(!result);
}
//*************************************************************************
TEST(is_heap_empty)
{
std::vector<int> data;
bool expected = std::is_heap(data.begin(), data.end());
bool result = etl::is_heap(data.begin(), data.end());
CHECK_EQUAL(expected, result);
CHECK(result);
}
//*************************************************************************
TEST(is_heap_single_element)
{
std::vector<int> data = { 42 };
bool expected = std::is_heap(data.begin(), data.end());
bool result = etl::is_heap(data.begin(), data.end());
CHECK_EQUAL(expected, result);
CHECK(result);
}
//*************************************************************************
TEST(is_heap_two_elements)
{
std::vector<int> data1 = { 5, 3 };
std::vector<int> data2 = { 3, 5 };
CHECK_EQUAL(std::is_heap(data1.begin(), data1.end()), etl::is_heap(data1.begin(), data1.end()));
CHECK_EQUAL(std::is_heap(data2.begin(), data2.end()), etl::is_heap(data2.begin(), data2.end()));
}
//*************************************************************************
TEST(is_heap_pointer)
{
int data[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
bool expected = std::is_heap(std::begin(data), std::end(data));
bool result = etl::is_heap(std::begin(data), std::end(data));
CHECK_EQUAL(expected, result);
}
//*************************************************************************
TEST(is_heap_after_make_heap)
{
// Test all permutations of a small dataset
std::vector<int> data = { 1, 2, 3, 4, 5 };
do
{
std::vector<int> test_data(data);
etl::make_heap(test_data.begin(), test_data.end());
CHECK(etl::is_heap(test_data.begin(), test_data.end()));
} while (std::next_permutation(data.begin(), data.end()));
}
//*************************************************************************
TEST(sort_heap_default)
{
std::vector<int> data1 = { 5, 3, 8, 1, 9, 2, 7, 4, 6, 10 };
std::vector<int> data2(data1);
std::make_heap(data1.begin(), data1.end());
etl::make_heap(data2.begin(), data2.end());
std::sort_heap(data1.begin(), data1.end());
etl::sort_heap(data2.begin(), data2.end());
bool isEqual = std::equal(data1.begin(), data1.end(), data2.begin());
CHECK(isEqual);
// Verify sorted ascending
CHECK(std::is_sorted(data2.begin(), data2.end()));
}
//*************************************************************************
TEST(sort_heap_compare)
{
std::vector<int> data1 = { 5, 3, 8, 1, 9, 2, 7, 4, 6, 10 };
std::vector<int> data2(data1);
std::make_heap(data1.begin(), data1.end(), Greater());
etl::make_heap(data2.begin(), data2.end(), Greater());
std::sort_heap(data1.begin(), data1.end(), Greater());
etl::sort_heap(data2.begin(), data2.end(), Greater());
bool isEqual = std::equal(data1.begin(), data1.end(), data2.begin());
CHECK(isEqual);
// Verify sorted descending
CHECK(std::is_sorted(data2.begin(), data2.end(), Greater()));
}
//*************************************************************************
TEST(sort_heap_empty)
{
std::vector<int> data;
etl::sort_heap(data.begin(), data.end());
CHECK(data.empty());
}
//*************************************************************************
TEST(sort_heap_single_element)
{
std::vector<int> data = { 42 };
etl::sort_heap(data.begin(), data.end());
CHECK_EQUAL(1U, data.size());
CHECK_EQUAL(42, data[0]);
}
//*************************************************************************
TEST(sort_heap_pointer)
{
int data1[] = { 5, 3, 8, 1, 9, 2, 7, 4, 6, 10 };
int data2[] = { 5, 3, 8, 1, 9, 2, 7, 4, 6, 10 };
std::make_heap(std::begin(data1), std::end(data1));
etl::make_heap(std::begin(data2), std::end(data2));
std::sort_heap(std::begin(data1), std::end(data1));
etl::sort_heap(std::begin(data2), std::end(data2));
bool isEqual = std::equal(std::begin(data1), std::end(data1), std::begin(data2));
CHECK(isEqual);
}
//*************************************************************************
TEST(sort_heap_all_permutations)
{
std::vector<int> initial = { 1, 2, 3, 4, 5 };
do
{
std::vector<int> data1(initial);
std::vector<int> data2(initial);
std::make_heap(data1.begin(), data1.end());
etl::make_heap(data2.begin(), data2.end());
std::sort_heap(data1.begin(), data1.end());
etl::sort_heap(data2.begin(), data2.end());
bool isEqual = std::equal(data1.begin(), data1.end(), data2.begin());
CHECK(isEqual);
} while (std::next_permutation(initial.begin(), initial.end()));
}
//*************************************************************************
TEST(sort_heap_duplicates)
{
std::vector<int> data1 = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
std::vector<int> data2(data1);
std::make_heap(data1.begin(), data1.end());
etl::make_heap(data2.begin(), data2.end());
std::sort_heap(data1.begin(), data1.end());
etl::sort_heap(data2.begin(), data2.end());
bool isEqual = std::equal(data1.begin(), data1.end(), data2.begin());
CHECK(isEqual);
}
//*************************************************************************
TEST(find)
{