655 lines
20 KiB
C++
655 lines
20 KiB
C++
/******************************************************************************
|
|
The MIT License(MIT)
|
|
|
|
Embedded Template Library.
|
|
https://github.com/ETLCPP/etl
|
|
https://www.etlcpp.com
|
|
|
|
Copyright(c) 2015 John Wellbelove, rlindeman
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files(the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions :
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
******************************************************************************/
|
|
|
|
#include "unit_test_framework.h"
|
|
|
|
#include <queue>
|
|
|
|
#include "etl/priority_queue.h"
|
|
#include "etl/math.h"
|
|
#include <functional>
|
|
#include <string>
|
|
|
|
#include "data.h"
|
|
|
|
namespace
|
|
{
|
|
using ItemM = TestDataM<std::string>;
|
|
|
|
struct Item
|
|
{
|
|
Item()
|
|
: c('a')
|
|
, i(1)
|
|
, d(1.2)
|
|
{
|
|
}
|
|
|
|
Item(char c_, int i_, double d_)
|
|
: c(c_)
|
|
, i(i_)
|
|
, d(d_)
|
|
{
|
|
}
|
|
|
|
char c;
|
|
int i;
|
|
double d;
|
|
};
|
|
|
|
bool operator == (const Item& lhs, const Item& rhs)
|
|
{
|
|
#include "etl/private/diagnostic_float_equal_push.h"
|
|
return (lhs.c == rhs.c) && (lhs.i == rhs.i) && (lhs.d == rhs.d);
|
|
#include "etl/private/diagnostic_pop.h"
|
|
}
|
|
|
|
bool operator < (const Item& lhs, const Item& rhs)
|
|
{
|
|
return (lhs.c < rhs.c);
|
|
}
|
|
|
|
std::ostream& operator << (std::ostream& os, const Item& item)
|
|
{
|
|
os << item.c << "," << item.i << "," << item.d;
|
|
return os;
|
|
}
|
|
|
|
SUITE(test_priority_queue)
|
|
{
|
|
static const size_t SIZE = 4UL;
|
|
|
|
//*************************************************************************
|
|
TEST(test_default_constructor)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
CHECK_EQUAL(priority_queue.size(), 0UL);
|
|
CHECK_EQUAL(priority_queue.available(), SIZE);
|
|
CHECK_EQUAL(priority_queue.max_size(), SIZE);
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_delete_via_ipriority_queue)
|
|
{
|
|
typedef etl::priority_queue<int, 4> priority_queue_t;
|
|
|
|
priority_queue_t* ppriority_queue = new etl::priority_queue<int, 4>;
|
|
|
|
etl::ipriority_queue<int, priority_queue_t::container_type, priority_queue_t::compare_type>* pipriority_queue = ppriority_queue;
|
|
|
|
pipriority_queue->push(1);
|
|
pipriority_queue->push(2);
|
|
pipriority_queue->push(3);
|
|
pipriority_queue->push(4);
|
|
|
|
delete pipriority_queue;
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_copy_constructor)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
priority_queue.push(3);
|
|
priority_queue.push(1);
|
|
priority_queue.push(4);
|
|
priority_queue.push(2);
|
|
|
|
etl::priority_queue<int, SIZE> priority_queue2(priority_queue);
|
|
|
|
CHECK(priority_queue.size() == priority_queue2.size());
|
|
|
|
while (!priority_queue.empty())
|
|
{
|
|
CHECK_EQUAL(priority_queue.top(), priority_queue2.top());
|
|
priority_queue.pop();
|
|
priority_queue2.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_move_constructor)
|
|
{
|
|
ItemM a("A"), b("B"), c("C"), d("D");
|
|
|
|
etl::priority_queue<ItemM, SIZE> priority_queue;
|
|
|
|
priority_queue.push(std::move(c));
|
|
priority_queue.push(std::move(d));
|
|
priority_queue.push(std::move(a));
|
|
priority_queue.push(std::move(b));
|
|
|
|
etl::priority_queue<ItemM, SIZE> priority_queue2(std::move(priority_queue));
|
|
|
|
CHECK_EQUAL(0U, priority_queue.size());
|
|
CHECK_EQUAL(SIZE, priority_queue2.size());
|
|
|
|
CHECK_EQUAL(priority_queue2.top().value, "D");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "C");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "B");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "A");
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_constructor_range)
|
|
{
|
|
int n[] = { 3, 4, 1, 2 };
|
|
etl::priority_queue<int, SIZE> priority_queue(std::begin(n), std::end(n));
|
|
std::priority_queue<int> compare_priority_queue(std::begin(n), std::end(n));
|
|
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK(!priority_queue.empty());
|
|
|
|
while (!priority_queue.empty())
|
|
{
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
compare_priority_queue.pop();
|
|
priority_queue.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_size)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
priority_queue.push(2);
|
|
priority_queue.push(3);
|
|
|
|
CHECK_EQUAL(3U, priority_queue.size());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_clear)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
priority_queue.push(2);
|
|
priority_queue.clear();
|
|
CHECK_EQUAL(0U, priority_queue.size());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_assign_range)
|
|
{
|
|
int n[] = { 3, 4, 1, 2 };
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
std::priority_queue<int> compare_priority_queue(std::begin(n), std::end(n));
|
|
|
|
priority_queue.assign(std::begin(n), std::end(n));
|
|
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK(!priority_queue.empty());
|
|
|
|
while (!priority_queue.empty())
|
|
{
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
compare_priority_queue.pop();
|
|
priority_queue.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_empty)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
CHECK(priority_queue.empty());
|
|
|
|
priority_queue.push(1);
|
|
|
|
CHECK(!priority_queue.empty());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_full)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
CHECK(!priority_queue.full());
|
|
|
|
priority_queue.push(1);
|
|
priority_queue.push(2);
|
|
priority_queue.push(3);
|
|
priority_queue.push(4);
|
|
|
|
CHECK(priority_queue.full());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_top)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
std::priority_queue<int> compare_priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(3);
|
|
compare_priority_queue.push(3);
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(2);
|
|
compare_priority_queue.push(2);
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(4);
|
|
compare_priority_queue.push(4);
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_top_const)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
const etl::priority_queue<int, SIZE>& constQueue = priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
CHECK_EQUAL(1, constQueue.top());
|
|
priority_queue.push(3);
|
|
CHECK_EQUAL(3, constQueue.top());
|
|
priority_queue.push(2);
|
|
CHECK_EQUAL(3, constQueue.top());
|
|
priority_queue.push(4);
|
|
CHECK_EQUAL(4, constQueue.top());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_push)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
std::priority_queue<int> compare_priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
|
|
priority_queue.push(2);
|
|
compare_priority_queue.push(2);
|
|
|
|
priority_queue.push(3);
|
|
compare_priority_queue.push(3);
|
|
|
|
priority_queue.push(4);
|
|
compare_priority_queue.push(4);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_push_movable)
|
|
{
|
|
ItemM a("A"), b("B"), c("C"), d("D");
|
|
|
|
etl::priority_queue<ItemM, SIZE> priority_queue;
|
|
std::priority_queue<ItemM> compare_priority_queue;
|
|
|
|
priority_queue.push(std::move(c));
|
|
priority_queue.push(std::move(d));
|
|
priority_queue.push(std::move(a));
|
|
priority_queue.push(std::move(b));
|
|
|
|
compare_priority_queue.push(ItemM("C"));
|
|
compare_priority_queue.push(ItemM("D"));
|
|
compare_priority_queue.push(ItemM("A"));
|
|
compare_priority_queue.push(ItemM("B"));
|
|
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK(!priority_queue.empty());
|
|
|
|
while (!priority_queue.empty())
|
|
{
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
compare_priority_queue.pop();
|
|
priority_queue.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_emplace)
|
|
{
|
|
etl::priority_queue<Item, 5> priority_queue;
|
|
std::priority_queue<Item> compare_priority_queue;
|
|
|
|
priority_queue.emplace();
|
|
compare_priority_queue.emplace();
|
|
|
|
priority_queue.emplace('d', 4, 7.8);
|
|
compare_priority_queue.emplace('d', 4, 7.8);
|
|
|
|
priority_queue.emplace('b', 2, 3.4);
|
|
compare_priority_queue.emplace('b', 2, 3.4);
|
|
|
|
priority_queue.emplace('a', 1, 1.2);
|
|
compare_priority_queue.emplace('a', 1, 1.2);
|
|
|
|
priority_queue.emplace('c', 3, 5.6);
|
|
compare_priority_queue.emplace('c', 3, 5.6);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_push_excess)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
for (size_t i = 0UL; i < priority_queue.max_size(); ++i)
|
|
{
|
|
priority_queue.push(1);
|
|
}
|
|
|
|
CHECK_THROW(priority_queue.push(1), etl::priority_queue_full);
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_pop)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
std::priority_queue<int> compare_priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
|
|
priority_queue.push(3);
|
|
compare_priority_queue.push(3);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(2);
|
|
compare_priority_queue.push(2);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), priority_queue.top());
|
|
|
|
priority_queue.pop();
|
|
compare_priority_queue.pop();
|
|
CHECK_EQUAL(compare_priority_queue.size(), priority_queue.size());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_pop_into)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
priority_queue.push(3);
|
|
priority_queue.push(4);
|
|
priority_queue.push(2);
|
|
|
|
int i;
|
|
|
|
priority_queue.pop_into(i);
|
|
CHECK_EQUAL(4, i);
|
|
|
|
priority_queue.pop_into(i);
|
|
CHECK_EQUAL(3, i);
|
|
|
|
priority_queue.pop_into(i);
|
|
CHECK_EQUAL(2, i);
|
|
|
|
priority_queue.pop_into(i);
|
|
CHECK_EQUAL(1, i);
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_assignment)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue;
|
|
|
|
priority_queue.push(1);
|
|
priority_queue.push(4);
|
|
priority_queue.push(3);
|
|
priority_queue.push(2);
|
|
|
|
etl::priority_queue<int, SIZE> priority_queue2;
|
|
|
|
priority_queue2 = priority_queue;
|
|
|
|
CHECK(priority_queue.size() == priority_queue2.size());
|
|
|
|
while (!priority_queue.empty())
|
|
{
|
|
CHECK_EQUAL(priority_queue.top(), priority_queue2.top());
|
|
priority_queue.pop();
|
|
priority_queue2.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_move_assignment)
|
|
{
|
|
ItemM a("A"), b("B"), c("C"), d("D");
|
|
|
|
etl::priority_queue<ItemM, SIZE> priority_queue;
|
|
|
|
priority_queue.push(std::move(c));
|
|
priority_queue.push(std::move(d));
|
|
priority_queue.push(std::move(a));
|
|
priority_queue.push(std::move(b));
|
|
|
|
etl::priority_queue<ItemM, SIZE> priority_queue2;
|
|
priority_queue2.push(ItemM("E"));
|
|
|
|
priority_queue2 = std::move(priority_queue);
|
|
|
|
CHECK_EQUAL(0U, priority_queue.size());
|
|
CHECK_EQUAL(SIZE, priority_queue2.size());
|
|
|
|
CHECK_EQUAL(priority_queue2.top().value, "D");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "C");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "B");
|
|
priority_queue2.pop();
|
|
CHECK_EQUAL(priority_queue2.top().value, "A");
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_assignment_interface)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue1;
|
|
|
|
priority_queue1.push(1);
|
|
priority_queue1.push(4);
|
|
priority_queue1.push(3);
|
|
priority_queue1.push(2);
|
|
|
|
etl::priority_queue<int, SIZE> priority_queue2;
|
|
|
|
etl::ipriority_queue<int, etl::vector<int, SIZE>>& ipriority_queue1 = priority_queue1;
|
|
etl::ipriority_queue<int, etl::vector<int, SIZE>>& ipriority_queue2 = priority_queue2;
|
|
|
|
ipriority_queue2 = ipriority_queue1;
|
|
|
|
CHECK(priority_queue1.size() == priority_queue2.size());
|
|
|
|
while (!priority_queue1.empty())
|
|
{
|
|
CHECK_EQUAL(priority_queue1.top(), priority_queue2.top());
|
|
priority_queue1.pop();
|
|
priority_queue2.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_self_assignment)
|
|
{
|
|
etl::priority_queue<int, SIZE> priority_queue1;
|
|
|
|
priority_queue1.push(1);
|
|
priority_queue1.push(4);
|
|
priority_queue1.push(3);
|
|
priority_queue1.push(2);
|
|
|
|
etl::priority_queue<int, SIZE> priority_queue2 = priority_queue1;
|
|
|
|
#include "etl/private/diagnostic_self_assign_overloaded_push.h"
|
|
priority_queue1 = priority_queue1;
|
|
#include "etl/private/diagnostic_pop.h"
|
|
|
|
|
|
CHECK(priority_queue1.size() == priority_queue2.size());
|
|
|
|
while (!priority_queue1.empty())
|
|
{
|
|
CHECK_EQUAL(priority_queue1.top(), priority_queue2.top());
|
|
priority_queue1.pop();
|
|
priority_queue2.pop();
|
|
}
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_interface)
|
|
{
|
|
typedef etl::priority_queue<int, SIZE> priority_queue_t;
|
|
priority_queue_t priority_queue;
|
|
etl::ipriority_queue<int, priority_queue_t::container_type, priority_queue_t::compare_type>& ipriority_queue = priority_queue;
|
|
|
|
std::priority_queue<int> compare_priority_queue;
|
|
|
|
ipriority_queue.push(1);
|
|
compare_priority_queue.push(1);
|
|
|
|
ipriority_queue.push(2);
|
|
compare_priority_queue.push(2);
|
|
|
|
ipriority_queue.push(3);
|
|
compare_priority_queue.push(3);
|
|
|
|
ipriority_queue.push(4);
|
|
compare_priority_queue.push(4);
|
|
CHECK_EQUAL(compare_priority_queue.size(), ipriority_queue.size());
|
|
CHECK_EQUAL(compare_priority_queue.top(), ipriority_queue.top());
|
|
}
|
|
|
|
//*************************************************************************
|
|
TEST(test_using_custom_compare)
|
|
{
|
|
etl::priority_queue<int, SIZE, etl::vector<int, SIZE>, std::less<int> > priority_queue1;
|
|
|
|
priority_queue1.push(1);
|
|
priority_queue1.push(4);
|
|
priority_queue1.push(3);
|
|
priority_queue1.push(2);
|
|
|
|
etl::priority_queue<int, SIZE, etl::vector<int, SIZE>, std::less<int> > priority_queue2;
|
|
|
|
etl::ipriority_queue<int, etl::vector<int, SIZE>, std::less<int>>& ipriority_queue1 = priority_queue1;
|
|
etl::ipriority_queue<int, etl::vector<int, SIZE>, std::less<int>>& ipriority_queue2 = priority_queue2;
|
|
|
|
ipriority_queue2 = ipriority_queue1;
|
|
|
|
CHECK(priority_queue1.size() == priority_queue2.size());
|
|
|
|
while (!priority_queue1.empty())
|
|
{
|
|
CHECK_EQUAL(priority_queue1.top(), priority_queue2.top());
|
|
priority_queue1.pop();
|
|
priority_queue2.pop();
|
|
}
|
|
}
|
|
};
|
|
}
|