2021-03-04 00:05:34 +03:00
|
|
|
/*
|
2021-04-22 23:40:43 +03:00
|
|
|
* Copyright (c) 2021, Idan Horowitz <idan.horowitz@serenityos.org>
|
2021-03-04 00:05:34 +03:00
|
|
|
*
|
2021-04-22 11:24:48 +03:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2021-03-04 00:05:34 +03:00
|
|
|
*/
|
|
|
|
|
2021-04-25 08:53:23 +03:00
|
|
|
#include <LibTest/TestCase.h>
|
2021-03-04 00:05:34 +03:00
|
|
|
|
|
|
|
#include <AK/BinaryHeap.h>
|
2022-12-04 21:02:33 +03:00
|
|
|
#include <AK/DeprecatedString.h>
|
2021-03-04 00:05:34 +03:00
|
|
|
|
2023-09-28 01:36:05 +03:00
|
|
|
using namespace Test::Randomized;
|
|
|
|
|
2021-03-04 00:05:34 +03:00
|
|
|
TEST_CASE(construct)
|
|
|
|
{
|
|
|
|
BinaryHeap<int, int, 5> empty;
|
|
|
|
EXPECT(empty.is_empty());
|
|
|
|
EXPECT(empty.size() == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE(construct_from_existing)
|
|
|
|
{
|
|
|
|
int keys[] = { 3, 2, 1 };
|
|
|
|
char values[] = { 'c', 'b', 'a' };
|
|
|
|
BinaryHeap<int, char, 5> from_existing(keys, values, 3);
|
|
|
|
EXPECT(from_existing.size() == 3);
|
|
|
|
EXPECT_EQ(from_existing.pop_min(), 'a');
|
|
|
|
EXPECT_EQ(from_existing.pop_min(), 'b');
|
|
|
|
EXPECT_EQ(from_existing.pop_min(), 'c');
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE(populate_int)
|
|
|
|
{
|
|
|
|
BinaryHeap<int, int, 5> ints;
|
|
|
|
ints.insert(1, 10);
|
|
|
|
ints.insert(3, 20);
|
|
|
|
ints.insert(2, 30);
|
|
|
|
EXPECT_EQ(ints.size(), 3u);
|
|
|
|
EXPECT_EQ(ints.pop_min(), 10);
|
|
|
|
EXPECT_EQ(ints.size(), 2u);
|
|
|
|
EXPECT_EQ(ints.pop_min(), 30);
|
|
|
|
EXPECT_EQ(ints.size(), 1u);
|
|
|
|
EXPECT_EQ(ints.pop_min(), 20);
|
|
|
|
EXPECT_EQ(ints.size(), 0u);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE(populate_string)
|
|
|
|
{
|
2022-12-04 21:02:33 +03:00
|
|
|
BinaryHeap<int, DeprecatedString, 5> strings;
|
2021-03-04 00:05:34 +03:00
|
|
|
strings.insert(1, "ABC");
|
|
|
|
strings.insert(2, "DEF");
|
|
|
|
EXPECT_EQ(strings.size(), 2u);
|
|
|
|
EXPECT_EQ(strings.pop_min(), "ABC");
|
|
|
|
EXPECT_EQ(strings.pop_min(), "DEF");
|
|
|
|
EXPECT(strings.is_empty());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_CASE(large_populate_reverse)
|
|
|
|
{
|
|
|
|
BinaryHeap<int, int, 1024> ints;
|
|
|
|
for (int i = 1023; i >= 0; i--) {
|
|
|
|
ints.insert(i, i);
|
|
|
|
}
|
|
|
|
EXPECT_EQ(ints.size(), 1024u);
|
|
|
|
for (int i = 0; i < 1024; i++) {
|
|
|
|
EXPECT_EQ(ints.peek_min(), i);
|
|
|
|
EXPECT_EQ(ints.pop_min(), i);
|
|
|
|
}
|
|
|
|
}
|
2023-09-28 01:36:05 +03:00
|
|
|
|
|
|
|
RANDOMIZED_TEST_CASE(pop_min_is_min)
|
|
|
|
{
|
|
|
|
GEN(vec, Gen::vector(1, 10, []() { return Gen::unsigned_int(); }));
|
|
|
|
|
|
|
|
auto sorted { vec };
|
|
|
|
AK::quick_sort(sorted);
|
|
|
|
|
|
|
|
BinaryHeap<u32, u32, 10> heap;
|
|
|
|
|
|
|
|
// insert in a non-sorted order
|
|
|
|
for (u32 n : vec) {
|
|
|
|
heap.insert(n, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
// check in a sorted order
|
|
|
|
for (u32 sorted_n : sorted) {
|
|
|
|
EXPECT_EQ(heap.pop_min(), sorted_n);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
RANDOMIZED_TEST_CASE(peek_min_same_as_pop_min)
|
|
|
|
{
|
|
|
|
GEN(vec, Gen::vector(1, 10, []() { return Gen::unsigned_int(); }));
|
|
|
|
BinaryHeap<u32, u32, 10> heap;
|
|
|
|
for (u32 n : vec) {
|
|
|
|
heap.insert(n, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!heap.is_empty()) {
|
|
|
|
u32 peeked = heap.peek_min();
|
|
|
|
u32 popped = heap.pop_min();
|
|
|
|
EXPECT_EQ(peeked, popped);
|
|
|
|
}
|
|
|
|
}
|