From aafb6ecf9b28734425f2a41246f09b128b3ccf97 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Sat, 16 Nov 2019 17:00:36 +0000 Subject: [PATCH] Indirect vector, external buffers --- include/etl/file_error_numbers.txt | 1 + include/etl/indirect_vector.h | 321 +-- include/etl/list.h | 2 +- include/etl/pool.h | 8 + include/etl/vector.h | 2 +- test/codeblocks/ETL.cbp | 1 + test/test_indirect_vector_external_buffer.cpp | 1836 +++++++++++++++++ test/vs2017/etl.vcxproj | 1 + test/vs2017/etl.vcxproj.filters | 3 + 9 files changed, 2013 insertions(+), 162 deletions(-) create mode 100644 test/test_indirect_vector_external_buffer.cpp diff --git a/include/etl/file_error_numbers.txt b/include/etl/file_error_numbers.txt index e752f7c3..23f13178 100644 --- a/include/etl/file_error_numbers.txt +++ b/include/etl/file_error_numbers.txt @@ -50,3 +50,4 @@ 50 binary 51 delegate 52 bitset +53 indirect_vector diff --git a/include/etl/indirect_vector.h b/include/etl/indirect_vector.h index 8a916cdd..99e64bdc 100644 --- a/include/etl/indirect_vector.h +++ b/include/etl/indirect_vector.h @@ -47,6 +47,9 @@ SOFTWARE. #pragma GCC diagnostic ignored "-Wunused-variable" #endif +#undef ETL_FILE +#define ETL_FILE "53" + //***************************************************************************** ///\defgroup indirect_vector indirect_vector /// A indirect_vector with the capacity defined at compile time. Objects are allocated from a pool and stored as pointers. @@ -55,6 +58,20 @@ SOFTWARE. namespace etl { + //*************************************************************************** + ///\ingroup vector + /// Vector full exception. + //*************************************************************************** + class indirect_vector_buffer_missmatch : public vector_exception + { + public: + + indirect_vector_buffer_missmatch(string_type file_name_, numeric_type line_number_) + : vector_exception(ETL_ERROR_TEXT("indirect_vector:buffer_missmatch", ETL_FILE"A"), file_name_, line_number_) + { + } + }; + //*************************************************************************** /// The base class for specifically sized vectors. /// Can be used as a reference type for all vectors containing a specific type. @@ -1149,6 +1166,7 @@ namespace etl : lookup(lookup_) , storage(storage_) { + ETL_ASSERT(lookup.capacity() <= storage.capacity(), ETL_ERROR(indirect_vector_buffer_missmatch)); } //********************************************************************* @@ -1167,6 +1185,27 @@ namespace etl lookup.clear(); } + //********************************************************************* + /// Move from a container. + //********************************************************************* + void move_container(iindirect_vector&& other) + { + if (this != &other) + { + initialise(); + + typename iindirect_vector::iterator itr = other.begin(); + + while (itr != other.end()) + { + push_back(std::move(*itr)); + ++itr; + } + + other.initialise(); + } + } + etl::ivector& lookup; etl::ipool& storage; @@ -1414,19 +1453,7 @@ namespace etl indirect_vector(indirect_vector&& other) : etl::iindirect_vector(lookup_vector, storage_pool) { - if (this != &other) - { - this->initialise(); - - typename etl::iindirect_vector::iterator itr = other.begin(); - while (itr != other.end()) - { - this->push_back(std::move(*itr)); - ++itr; - } - - other.initialise(); - } + this->move_container(std::move(other)); } //************************************************************************* @@ -1434,18 +1461,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - if (&rhs != this) - { - this->clear(); - typename etl::iindirect_vector::iterator itr = rhs.begin(); - while (itr != rhs.end()) - { - this->push_back(std::move(*itr)); - ++itr; - } - - rhs.initialise(); - } + this->move_container(std::move(rhs)); return *this; } @@ -1465,146 +1481,131 @@ namespace etl etl::pool storage_pool; }; -// //*************************************************************************** -// /// A indirect_vector implementation that uses a fixed size buffer. -// /// The buffer is supplied on construction. -// ///\tparam T The element type. -// ///\ingroup indirect_vector -// //*************************************************************************** -// template -// class indirect_vector : public etl::iindirect_vector -// { -// public: -// -// //************************************************************************* -// /// Constructor. -// //************************************************************************* -// indirect_vector(void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->initialise(); -// } -// -// //************************************************************************* -// /// Constructor, with size. -// ///\param initial_size The initial size of the indirect_vector. -// //************************************************************************* -// explicit indirect_vector(size_t initial_size, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->initialise(); -// this->resize(initial_size); -// } -// -// //************************************************************************* -// /// Constructor, from initial size and value. -// ///\param initial_size The initial size of the indirect_vector. -// ///\param value The value to fill the indirect_vector with. -// //************************************************************************* -// indirect_vector(size_t initial_size, typename etl::iindirect_vector::parameter_t value, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->initialise(); -// this->resize(initial_size, value); -// } -// -// //************************************************************************* -// /// Constructor, from an iterator range. -// ///\tparam TIterator The iterator type. -// ///\param first The iterator to the first element. -// ///\param last The iterator to the last element + 1. -// //************************************************************************* -// template -// indirect_vector(TIterator first, TIterator last, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->assign(first, last); -// } -// -//#if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) -// //************************************************************************* -// /// Constructor, from an initializer_list. -// //************************************************************************* -// indirect_vector(std::initializer_list init, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->assign(init.begin(), init.end()); -// } -//#endif -// -// //************************************************************************* -// /// Copy constructor. -// //************************************************************************* -// indirect_vector(const indirect_vector& other, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// this->assign(other.begin(), other.end()); -// } -// -// //************************************************************************* -// /// Assignment operator. -// //************************************************************************* -// indirect_vector& operator = (const indirect_vector& rhs) -// { -// if (&rhs != this) -// { -// this->assign(rhs.cbegin(), rhs.cend()); -// } -// -// return *this; -// } -// -//#if ETL_CPP11_SUPPORTED -// //************************************************************************* -// /// Move constructor. -// //************************************************************************* -// indirect_vector(indirect_vector&& other, void* buffer, size_t max_size) -// : etl::iindirect_vector(reinterpret_cast(buffer), max_size) -// { -// if (this != &other) -// { -// this->initialise(); -// -// this->p_buffer = other.p_buffer; -// this->p_end = other.p_end; -// -// this->initialise_destination_external_buffer_after_move(); -// other.initialise_source_external_buffer_after_move(); -// } -// } -// -// //************************************************************************* -// /// Move assignment operator. -// //************************************************************************* -// indirect_vector& operator = (indirect_vector&& rhs) -// { -// if (&rhs != this) -// { -// this->clear(); -// this->p_buffer = rhs.p_buffer; -// this->p_end = rhs.p_end; -// -// this->initialise_destination_external_buffer_after_move(); -// rhs.initialise_source_external_buffer_after_move(); -// } -// -// return *this; -// } -//#endif -// -// //************************************************************************* -// /// Destructor. -// //************************************************************************* -// ~indirect_vector() -// { -// this->clear(); -// } -// }; + //*************************************************************************** + /// A indirect_vector implementation that uses a fixed size buffer. + /// The buffer is supplied on construction. + ///\tparam T The element type. + ///\ingroup indirect_vector + //*************************************************************************** + template + class indirect_vector : public etl::iindirect_vector + { + public: + + //************************************************************************* + /// Constructor. + //************************************************************************* + indirect_vector(etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->initialise(); + } + + //************************************************************************* + /// Constructor, with size. + ///\param initial_size The initial size of the indirect_vector. + //************************************************************************* + explicit indirect_vector(size_t initial_size, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->initialise(); + this->resize(initial_size); + } + + //************************************************************************* + /// Constructor, from initial size and value. + ///\param initial_size The initial size of the indirect_vector. + ///\param value The value to fill the indirect_vector with. + //************************************************************************* + indirect_vector(size_t initial_size, typename etl::iindirect_vector::parameter_t value, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->initialise(); + this->resize(initial_size, value); + } + + //************************************************************************* + /// Constructor, from an iterator range. + ///\tparam TIterator The iterator type. + ///\param first The iterator to the first element. + ///\param last The iterator to the last element + 1. + //************************************************************************* + template + indirect_vector(TIterator first, TIterator last, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->assign(first, last); + } + +#if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) + //************************************************************************* + /// Constructor, from an initializer_list. + //************************************************************************* + indirect_vector(std::initializer_list init, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->assign(init.begin(), init.end()); + } +#endif + + //************************************************************************* + /// Copy constructor. + //************************************************************************* + indirect_vector(const indirect_vector& other, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->assign(other.begin(), other.end()); + } + + //************************************************************************* + /// Assignment operator. + //************************************************************************* + indirect_vector& operator = (const indirect_vector& rhs) + { + if (&rhs != this) + { + this->assign(rhs.cbegin(), rhs.cend()); + } + + return *this; + } + +#if ETL_CPP11_SUPPORTED + //************************************************************************* + /// Move constructor. + //************************************************************************* + indirect_vector(indirect_vector&& other, etl::ivector& lookup_, etl::ipool& pool_) + : etl::iindirect_vector(lookup_, pool_) + { + this->move_container(std::move(other)); + } + + //************************************************************************* + /// Move assignment operator. + //************************************************************************* + indirect_vector& operator = (indirect_vector&& rhs) + { + this->move_container(std::move(rhs)); + + return *this; + } +#endif + + //************************************************************************* + /// Destructor. + //************************************************************************* + ~indirect_vector() + { + this->clear(); + } + }; } #ifdef ETL_COMPILER_GCC #pragma GCC diagnostic pop #endif +#undef ETL_FILE + #endif diff --git a/include/etl/list.h b/include/etl/list.h index 8d03fe48..f6ea7616 100644 --- a/include/etl/list.h +++ b/include/etl/list.h @@ -1386,7 +1386,7 @@ namespace etl { if (&other != this) { - ilist::iterator itr = other.begin(); + typename ilist::iterator itr = other.begin(); while (itr != other.end()) { to = insert(to, std::move(*itr++)); diff --git a/include/etl/pool.h b/include/etl/pool.h index baf15a62..56adb235 100644 --- a/include/etl/pool.h +++ b/include/etl/pool.h @@ -288,6 +288,14 @@ namespace etl return MAX_SIZE; } + //************************************************************************* + /// Returns the maximum number of items in the pool. + //************************************************************************* + size_t capacity() const + { + return MAX_SIZE; + } + //************************************************************************* /// Returns the number of free items in the pool. //************************************************************************* diff --git a/include/etl/vector.h b/include/etl/vector.h index a2cb34fd..ac05ce40 100644 --- a/include/etl/vector.h +++ b/include/etl/vector.h @@ -1627,7 +1627,7 @@ namespace etl /// Constructor, with size. ///\param initial_size The initial size of the vector. //************************************************************************* - explicit vector(size_t initial_size, void* buffer, size_t max_size) + vector(size_t initial_size, void* buffer, size_t max_size) : etl::ivector(reinterpret_cast(buffer), max_size) { this->initialise(); diff --git a/test/codeblocks/ETL.cbp b/test/codeblocks/ETL.cbp index fe5176f4..e0b2ee4a 100644 --- a/test/codeblocks/ETL.cbp +++ b/test/codeblocks/ETL.cbp @@ -305,6 +305,7 @@ + diff --git a/test/test_indirect_vector_external_buffer.cpp b/test/test_indirect_vector_external_buffer.cpp new file mode 100644 index 00000000..c4ef9669 --- /dev/null +++ b/test/test_indirect_vector_external_buffer.cpp @@ -0,0 +1,1836 @@ +///****************************************************************************** +//The MIT License(MIT) +// +//Embedded Template Library. +//https://github.com/ETLCPP/etl +//https://www.etlcpp.com +// +//Copyright(c) 2019 jwellbelove +// +//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 "UnitTest++.h" + +#include +#include +#include +#include + +#include "etl/indirect_vector.h" +#include "etl/vector.h" +#include "etl/pool.h" + +#include "data.h" + +namespace +{ + SUITE(test_indirect_vector_external_buffer) + { + static const size_t SIZE = 12; + + typedef TestDataNDC NDC; + typedef TestDataDC DC; + + using LookupDC = etl::vector; + using LookupDCLarger = etl::vector; + using PoolDC = etl::pool; + + using LookupNDC = etl::vector; + using PoolNDC = etl::pool; + + using LookupInt = etl::vector; + using PoolInt = etl::pool; + + using LookupUniquePtr = etl::vector*, SIZE>; + using PoolUniquePtr = etl::pool, SIZE>; + + static NDC ndc("NDC"); + + typedef etl::indirect_vector DataNDC; + typedef etl::iindirect_vector IDataNDC; + typedef std::vector CompareDataNDC; + + typedef etl::indirect_vector DataDC; + typedef etl::iindirect_vector IDataDC; + typedef std::vector CompareDataDC; + + CompareDataNDC initial_data; + CompareDataNDC less_data; + CompareDataNDC greater_data; + CompareDataNDC shorter_data; + CompareDataNDC different_data; + CompareDataNDC insert_data; + CompareDataNDC ordered_data; + CompareDataNDC part_ordered_data; + CompareDataNDC part_reverse_ordered_data; + CompareDataNDC stable_default_ordered_data; + CompareDataNDC stable_reverse_ordered_data; + CompareDataNDC stable_greater_ordered_data; + CompareDataNDC stable_greater_reverse_ordered_data; + CompareDataNDC unordered_data; + CompareDataNDC stable_part_ordered_data; + CompareDataNDC stable_part_greater_ordered_data; + + //************************************************************************* + struct SetupFixture + { + SetupFixture() + { + NDC n[] = { NDC("0"), NDC("1"), NDC("2"), NDC("3"), NDC("4"), NDC("4"), NDC("4"), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + NDC n_insert[] = { NDC("11"), NDC("12"), NDC("13") }; + NDC n_less[] = { NDC("0"), NDC("1"), NDC("2"), NDC("3"), NDC("4"), NDC("4"), NDC("4"), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + NDC n_greater[] = { NDC("0"), NDC("1"), NDC("2"), NDC("4"), NDC("4"), NDC("4"), NDC("4"), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + + NDC n_unordered[] = { NDC("1"), NDC("4", 1), NDC("7"), NDC("4", 2), NDC("2"), NDC("4", 3), NDC("3"), NDC("6"), NDC("9"), NDC("0"), NDC("8"), NDC("5") }; + + NDC n_ordered[] = { NDC("0"), NDC("1"), NDC("2"), NDC("3"), NDC("4"), NDC("4"), NDC("4"), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + NDC n_stable_default_ordered[] = { NDC("0"), NDC("1"), NDC("2"), NDC("3"), NDC("4", 1), NDC("4", 2), NDC("4", 3), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + NDC n_stable_reverse_ordered[] = { NDC("0"), NDC("1"), NDC("2"), NDC("3"), NDC("4", 3), NDC("4", 2), NDC("4", 1), NDC("5"), NDC("6"), NDC("7"), NDC("8"), NDC("9") }; + NDC n_stable_greater_ordered[] = { NDC("9"), NDC("8"), NDC("7"), NDC("6"), NDC("5"), NDC("4", 1), NDC("4", 2), NDC("4", 3), NDC("3"), NDC("2"), NDC("1"), NDC("0") }; + NDC n_stable_greater_reverse_ordered_data[] = { NDC("9"), NDC("8"), NDC("7"), NDC("6"), NDC("5"), NDC("4", 3), NDC("4", 2), NDC("4", 1), NDC("3"), NDC("2"), NDC("1"), NDC("0") }; + + NDC n_part_ordered[] = { NDC("1"), NDC("4", 1), NDC("0"), NDC("2"), NDC("3"), NDC("4"), NDC("4"), NDC("6"), NDC("7"), NDC("9"), NDC("8"), NDC("5") }; + NDC n_part_reverse_ordered[] = { NDC("1"), NDC("4"), NDC("9"), NDC("7"), NDC("6"), NDC("4"), NDC("4"), NDC("3"), NDC("2"), NDC("0"), NDC("8"), NDC("5") }; + + NDC n_stable_part_ordered[] = { NDC("1"), NDC("4", 1), NDC("0"), NDC("2"), NDC("3"), NDC("4", 2), NDC("4", 3), NDC("6"), NDC("7"), NDC("9"), NDC("8"), NDC("5") }; + NDC n_stable_part_greater_ordered[] = { NDC("1"), NDC("4", 1), NDC("9"), NDC("7"), NDC("6"), NDC("4", 2), NDC("4", 3), NDC("3"), NDC("2"), NDC("0"), NDC("8"), NDC("5") }; + + + initial_data.assign(std::begin(n), std::end(n)); + insert_data.assign(std::begin(n_insert), std::end(n_insert)); + less_data.assign(std::begin(n_less), std::end(n_less)); + greater_data.assign(std::begin(n_greater), std::end(n_greater)); + shorter_data.assign(std::begin(n_greater), std::end(n_greater) - 1); + different_data.assign(initial_data.rbegin(), initial_data.rend()); + ordered_data.assign(std::begin(n_ordered), std::end(n_ordered)); + part_ordered_data.assign(std::begin(n_part_ordered), std::end(n_part_ordered)); + part_reverse_ordered_data.assign(std::begin(n_part_reverse_ordered), std::end(n_part_reverse_ordered)); + unordered_data.assign(std::begin(n_unordered), std::end(n_unordered)); + stable_default_ordered_data.assign(std::begin(n_stable_default_ordered), std::end(n_stable_default_ordered)); + stable_reverse_ordered_data.assign(std::begin(n_stable_reverse_ordered), std::end(n_stable_reverse_ordered)); + stable_greater_ordered_data.assign(std::begin(n_stable_greater_ordered), std::end(n_stable_greater_ordered)); + stable_greater_reverse_ordered_data.assign(std::begin(n_stable_greater_reverse_ordered_data), std::end(n_stable_greater_reverse_ordered_data)); + stable_part_ordered_data.assign(std::begin(n_stable_part_ordered), std::end(n_stable_part_ordered)); + stable_part_greater_ordered_data.assign(std::begin(n_stable_part_greater_ordered), std::end(n_stable_part_greater_ordered)); + } + }; + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_default_constructor) + { + LookupDC lookup; + PoolDC pool; + + DataDC data(lookup, pool); + + CHECK_EQUAL(data.size(), size_t(0)); + CHECK(data.empty()); + CHECK_EQUAL(data.capacity(), SIZE); + CHECK_EQUAL(data.max_size(), SIZE); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_default_constructor_buffer_mismatch) + { + LookupDCLarger lookup; + PoolDC pool; + + CHECK_THROW(DataDC data(lookup, pool), etl::indirect_vector_buffer_missmatch); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_destruct_via_ivector) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + + int current_count = NDC::get_instance_count(); + + DataNDC* p = new DataNDC(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + delete p; + + DataNDC* pdata = new DataNDC(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + CHECK_EQUAL(int(current_count + INITIAL_SIZE), NDC::get_instance_count()); + + IDataNDC* pidata = pdata; + delete pidata; + CHECK_EQUAL(current_count, NDC::get_instance_count()); + } + + //************************************************************************* + TEST(test_iterator_comparison_empty) + { + LookupDC lookup; + PoolDC pool; + + DataDC data(lookup, pool); + + CHECK(data.begin() == data.end()); + CHECK(data.cbegin() == data.cend()); + CHECK(data.rbegin() == data.rend()); + CHECK(data.crbegin() == data.crend()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_constructor_size) + { + LookupDC lookup; + PoolDC pool; + + const size_t INITIAL_SIZE = 5; + DataDC data(INITIAL_SIZE, lookup, pool); + + CHECK(data.size() == INITIAL_SIZE); + CHECK(!data.empty()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_constructor_size_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + + std::vector compare_data(INITIAL_SIZE, INITIAL_VALUE); + DataNDC data(size_t(5), NDC("1"), lookup, pool); + + CHECK(data.size() == INITIAL_SIZE); + CHECK(!data.empty()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_constructor_size_excess) + { + LookupDC lookup; + PoolDC pool; + + CHECK_THROW(DataDC data(SIZE + 1, lookup, pool), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_constructor_range) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + CHECK(data.size() == SIZE); + CHECK(!data.empty()); + } + + //************************************************************************* + TEST(test_constructor_initializer_list) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data = { NDC("0"), NDC("1"), NDC("2"), NDC("3") }; + DataNDC data({ NDC("0"), NDC("1"), NDC("2"), NDC("3") }, lookup, pool); + + CHECK_EQUAL(compare_data.size(), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end(), data.begin())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_copy_constructor) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + DataNDC data(initial_data.begin(), initial_data.end(), lookup1, pool1); + DataNDC data2(data, lookup2, pool2); + CHECK(data2 == data); + + data2[2] = NDC("X"); + CHECK(data2 != data); + } + + //************************************************************************* + TEST(test_move_constructor) + { + typedef etl::indirect_vector, 0> Data; + + LookupUniquePtr lookup1; + PoolUniquePtr pool1; + + LookupUniquePtr lookup2; + PoolUniquePtr pool2; + + std::unique_ptr p1(new uint32_t(1U)); + std::unique_ptr p2(new uint32_t(2U)); + std::unique_ptr p3(new uint32_t(3U)); + std::unique_ptr p4(new uint32_t(4U)); + + Data data1(lookup1, pool1); + data1.push_back(std::move(p1)); + data1.push_back(std::move(p2)); + data1.push_back(std::move(p3)); + data1.push_back(std::move(p4)); + + CHECK(!bool(p1)); + CHECK(!bool(p2)); + CHECK(!bool(p3)); + CHECK(!bool(p4)); + + Data data2(std::move(data1), lookup2, pool2); + + CHECK_EQUAL(0U, data1.size()); + CHECK_EQUAL(4U, data2.size()); + + CHECK_EQUAL(1U, *data2[0]); + CHECK_EQUAL(2U, *data2[1]); + CHECK_EQUAL(3U, *data2[2]); + CHECK_EQUAL(4U, *data2[3]); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_assignment) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + DataNDC data(initial_data.begin(), initial_data.end(), lookup1, pool1); + DataNDC other_data(lookup2, pool2); + + other_data = data; + + bool is_equal = std::equal(data.begin(), + data.end(), + other_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST(test_move_assignment) + { + const size_t SIZE = 10U; + typedef etl::indirect_vector, 0> Data; + + LookupUniquePtr lookup1; + PoolUniquePtr pool1; + + LookupUniquePtr lookup2; + PoolUniquePtr pool2; + + std::unique_ptr p1(new uint32_t(1U)); + std::unique_ptr p2(new uint32_t(2U)); + std::unique_ptr p3(new uint32_t(3U)); + std::unique_ptr p4(new uint32_t(4U)); + + Data data1(lookup1, pool1); + data1.push_back(std::move(p1)); + data1.push_back(std::move(p2)); + data1.push_back(std::move(p3)); + data1.push_back(std::move(p4)); + + CHECK(!bool(p1)); + CHECK(!bool(p2)); + CHECK(!bool(p3)); + CHECK(!bool(p4)); + + Data data2(lookup2, pool2); + data2 = std::move(data1); + + CHECK_EQUAL(0U, data1.size()); + CHECK_EQUAL(4U, data2.size()); + + CHECK_EQUAL(1U, *data2[0]); + CHECK_EQUAL(2U, *data2[1]); + CHECK_EQUAL(3U, *data2[2]); + CHECK_EQUAL(4U, *data2[3]); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_assignment_iterface) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + DataNDC data1(initial_data.begin(), initial_data.end(), lookup1, pool1); + DataNDC data2(lookup2, pool2); + + IDataNDC& idata1 = data1; + IDataNDC& idata2 = data2; + + idata2 = idata1; + + bool is_equal = std::equal(data1.begin(), + data1.end(), + data2.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST(test_move_assignment_interface) + { + LookupUniquePtr lookup1; + PoolUniquePtr pool1; + + LookupUniquePtr lookup2; + PoolUniquePtr pool2; + + typedef etl::indirect_vector, 0U> Data; + typedef etl::iindirect_vector> IData; + + std::unique_ptr p1(new uint32_t(1U)); + std::unique_ptr p2(new uint32_t(2U)); + std::unique_ptr p3(new uint32_t(3U)); + std::unique_ptr p4(new uint32_t(4U)); + + Data data1(lookup1, pool1); + data1.push_back(std::move(p1)); + data1.push_back(std::move(p2)); + data1.push_back(std::move(p3)); + data1.push_back(std::move(p4)); + + Data data2(lookup2, pool2); + + IData& idata1 = data1; + IData& idata2 = data2; + + idata2 = std::move(idata1); + + CHECK_EQUAL(0U, data1.size()); + CHECK_EQUAL(4U, data2.size()); + + CHECK_EQUAL(1U, *data2[0]); + CHECK_EQUAL(2U, *data2[1]); + CHECK_EQUAL(3U, *data2[2]); + CHECK_EQUAL(4U, *data2[3]); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_self_assignment) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + DataNDC data(initial_data.begin(), initial_data.end(), lookup1, pool1); + DataNDC other_data(data, lookup2, pool2); + + other_data = other_data; + + bool is_equal = std::equal(data.begin(), + data.end(), + other_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_begin) + { + LookupDC lookup1; + PoolDC pool1; + + LookupDC lookup2; + PoolDC pool2; + + DataDC data(10, lookup1, pool1); + const DataDC constData(10, lookup2, pool2); + + CHECK_EQUAL(&data[0], &(*data.begin())); + CHECK_EQUAL(&constData[0], &(*constData.begin())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_end) + { + LookupDC lookup1; + PoolDC pool1; + + LookupDC lookup2; + PoolDC pool2; + + DataDC data(10, lookup1, pool1); + const DataDC constData(10, lookup2, pool2); + + CHECK_EQUAL(&data[10], &(*data.end())); + CHECK_EQUAL(&constData[10], &(constData.end())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_resize_up) + { + LookupDC lookup; + PoolDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t NEW_SIZE = 8; + + DataDC data(INITIAL_SIZE, lookup, pool); + data.resize(NEW_SIZE); + + CHECK_EQUAL(data.size(), NEW_SIZE); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_resize_up_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t NEW_SIZE = 8; + const NDC INITIAL_VALUE("1"); + + DataNDC data(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + data.resize(NEW_SIZE, INITIAL_VALUE); + + std::vector compare_data(NEW_SIZE, INITIAL_VALUE); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), data.end(), compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_resize_excess) + { + LookupDC lookup; + PoolDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t NEW_SIZE = SIZE + 1; + + DataDC data(INITIAL_SIZE, lookup, pool); + + CHECK_THROW(data.resize(NEW_SIZE), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_resize_down) + { + LookupDC lookup; + PoolDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t NEW_SIZE = 2; + + DataDC data(INITIAL_SIZE, lookup, pool); + data.resize(NEW_SIZE); + + CHECK_EQUAL(data.size(), NEW_SIZE); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_resize_down_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t NEW_SIZE = 2; + const NDC INITIAL_VALUE("1"); + + DataNDC data(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + data.resize(NEW_SIZE, INITIAL_VALUE); + + CHECK_EQUAL(data.size(), NEW_SIZE); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_empty) + { + LookupDC lookup; + PoolDC pool; + + DataDC data(lookup, pool); + data.resize(data.max_size()); + + CHECK(data.full()); + CHECK(!data.empty()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_full) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(lookup, pool); + + CHECK(!data.full()); + CHECK(data.empty()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_index) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(data[i], compare_data[i]); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_index_const) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + const DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(data[i], compare_data[i]); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_at) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(data.at(i), compare_data.at(i)); + } + + CHECK_THROW(data.at(data.size()), etl::vector_out_of_bounds); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_at_const) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + const DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(data.at(i), compare_data.at(i)); + } + + CHECK_THROW(data.at(data.size()), etl::vector_out_of_bounds); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_front) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + CHECK(data.front() == compare_data.front()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_front_const) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + const DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + CHECK(data.front() == compare_data.front()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_back) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + CHECK(data.back() == compare_data.back()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_back_const) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + const DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + CHECK(data.back() == compare_data.back()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_data) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + DataNDC::indirect_pointer p = data.data(); + + for (size_t i = 0U; i < data.size(); ++i) + { + CHECK(data[i] == **p); + ++p; + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_data_const) + { + LookupNDC lookup; + PoolNDC pool; + + const DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + DataNDC::indirect_const_pointer p = data.data(); + + for (size_t i = 0U; i < data.size(); ++i) + { + CHECK(data[i] == **p); + ++p; + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_assign_range) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(lookup, pool); + + data.assign(compare_data.begin(), compare_data.end()); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_assign_size_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + std::vector compare_data(INITIAL_SIZE, INITIAL_VALUE); + + DataNDC data(lookup, pool); + data.assign(INITIAL_SIZE, INITIAL_VALUE); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_assign_size_value_excess) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = SIZE; + const size_t EXCESS_SIZE = SIZE + 1; + const NDC INITIAL_VALUE("1"); + std::vector compare_data(INITIAL_SIZE, INITIAL_VALUE); + + DataNDC data(lookup, pool); + + CHECK_THROW(data.assign(EXCESS_SIZE, INITIAL_VALUE), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_push_back) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + for (size_t i = 0; i < SIZE; ++i) + { + std::string value(" "); + value[0] = char('A' + i); + compare_data.push_back(NDC(value)); + data.push_back(NDC(value)); + } + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_push_back_excess) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(lookup, pool); + + for (size_t i = 0; i < SIZE; ++i) + { + std::string value(" "); + value[0] = char('A' + i); + data.push_back(NDC(value)); + } + + CHECK_THROW(data.push_back(NDC("Z")), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_emplace_back) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + for (size_t i = 0; i < SIZE; ++i) + { + std::string value(" "); + value[0] = char('A' + i); + compare_data.emplace_back(value); + data.emplace_back(value); + } + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_push_back_unique_ptr) + { + LookupUniquePtr lookup; + PoolUniquePtr pool; + + etl::indirect_vector, 0U> data(lookup, pool); + + std::unique_ptr p1(new uint32_t(1)); + std::unique_ptr p2(new uint32_t(2)); + std::unique_ptr p3(new uint32_t(3)); + std::unique_ptr p4(new uint32_t(4)); + + data.push_back(std::move(p1)); + data.push_back(std::move(p2)); + data.push_back(std::move(p3)); + data.push_back(std::move(p4)); + + CHECK(!bool(p1)); + CHECK(!bool(p2)); + CHECK(!bool(p3)); + CHECK(!bool(p4)); + + CHECK_EQUAL(1, *data[0]); + CHECK_EQUAL(2, *data[1]); + CHECK_EQUAL(3, *data[2]); + CHECK_EQUAL(4, *data[3]); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_int) + { + LookupInt lookup; + PoolInt pool; + + etl::indirect_vector data(lookup, pool); + + int p1(1); + int p2(2); + int p3(3); + int p4(4); + + data.insert(data.begin(), p1); + data.insert(data.begin(), p2); + data.insert(data.begin(), p3); + data.insert(data.begin(), p4); + + CHECK_EQUAL(4, data[0]); + CHECK_EQUAL(3, data[1]); + CHECK_EQUAL(2, data[2]); + CHECK_EQUAL(1, data[3]); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_unique_ptr) + { + LookupUniquePtr lookup; + PoolUniquePtr pool; + + etl::indirect_vector, 0U> data(lookup, pool); + + std::unique_ptr p1(new uint32_t(1)); + std::unique_ptr p2(new uint32_t(2)); + std::unique_ptr p3(new uint32_t(3)); + std::unique_ptr p4(new uint32_t(4)); + + data.insert(data.begin(), std::move(p1)); + data.insert(data.begin(), std::move(p2)); + data.insert(data.begin(), std::move(p3)); + data.insert(data.begin(), std::move(p4)); + + CHECK(!bool(p1)); + CHECK(!bool(p2)); + CHECK(!bool(p3)); + CHECK(!bool(p4)); + + CHECK_EQUAL(1, *data[3]); + CHECK_EQUAL(4, *data[0]); + CHECK_EQUAL(3, *data[1]); + CHECK_EQUAL(2, *data[2]); + + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_pop_back) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + compare_data.pop_back(); + compare_data.pop_back(); + + data.pop_back(); + data.pop_back(); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_pop_back_exception) + { + LookupDC lookup; + PoolDC pool; + + DataDC data(lookup, pool); + + data.resize(2); + + data.pop_back(); + data.pop_back(); + + CHECK_THROW(data.pop_back(), etl::vector_empty); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + + for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset) + { + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + + data.insert(data.begin() + offset, INITIAL_VALUE); + compare_data.insert(compare_data.begin() + offset, INITIAL_VALUE); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_emplace_position_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const std::string INITIAL_VALUE("1"); + + for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset) + { + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + + data.emplace(data.begin() + offset, INITIAL_VALUE); + compare_data.emplace(compare_data.begin() + offset, INITIAL_VALUE); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_value_excess) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = SIZE; + const NDC INITIAL_VALUE("1"); + const NDC UNINITIALISED_VALUE("Z"); + + DataNDC data(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + + size_t offset = 2; + + CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full); + + offset = 0; + + CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full); + + offset = data.size(); + + CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_n_value) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const size_t INSERT_SIZE = 3; + const NDC INITIAL_VALUE("1"); + + for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset) + { + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE); + compare_data.insert(compare_data.begin() + offset, INSERT_SIZE, INITIAL_VALUE); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_n_value_excess) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = SIZE; + const size_t INSERT_SIZE = 4; + const NDC INITIAL_VALUE("1"); + + DataNDC data(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + + size_t offset = 0; + + CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full); + + offset = 2; + + CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full); + + offset = 4; + + CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full); + + offset = data.size(); + + CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_range) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + + for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset) + { + CompareDataNDC compare_data; + DataNDC data(lookup, pool); + + data.resize(SIZE, NDC("Z")); + + data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE); + data.insert(data.begin() + offset, insert_data.begin(), insert_data.end()); + compare_data.insert(compare_data.begin() + offset, insert_data.begin(), insert_data.end()); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_insert_position_range_excess) + { + LookupNDC lookup; + PoolNDC pool; + + const size_t INITIAL_SIZE = 5; + const NDC INITIAL_VALUE("1"); + + DataNDC data(INITIAL_SIZE, INITIAL_VALUE, lookup, pool); + + size_t offset = 0; + + CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full); + + offset = 2; + + CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full); + + offset = 4; + + CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full); + + offset = data.size(); + + CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_erase_single) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + compare_data.erase(compare_data.begin() + 2); + + data.erase(data.begin() + 2); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_erase_range) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + DataNDC data(initial_data.begin(), initial_data.end(), lookup, pool); + + compare_data.erase(compare_data.begin() + 2, compare_data.begin() + 4); + + data.erase(data.begin() + 2, data.begin() + 4); + + CHECK_EQUAL(compare_data.size(), data.size()); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_clear) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + data.clear(); + + CHECK_EQUAL(data.size(), size_t(0)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_iterator) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + bool is_equal = std::equal(data.begin(), + data.end(), + compare_data.begin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_const_iterator) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + bool is_equal = std::equal(data.cbegin(), + data.cend(), + compare_data.cbegin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_reverse_iterator) + { + LookupNDC lookup; + PoolNDC pool; + + CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + bool is_equal = std::equal(data.rbegin(), + data.rend(), + compare_data.rbegin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_const_reverse_iterator) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + const DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + bool is_equal = std::equal(data.crbegin(), + data.crend(), + compare_data.crbegin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_const_reverse_iterator2) + { + LookupNDC lookup; + PoolNDC pool; + + const CompareDataNDC compare_data(initial_data.begin(), initial_data.end()); + + const DataNDC data(compare_data.begin(), compare_data.end(), lookup, pool); + + bool is_equal = std::equal(data.rbegin(), + data.rend(), + compare_data.rbegin()); + + CHECK(is_equal); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_equal) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + const DataNDC initial1(initial_data.begin(), initial_data.end(), lookup1, pool1); + const DataNDC initial2(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK(initial1 == initial2); + + const DataNDC different(different_data.begin(), different_data.end(), lookup3, pool3); + + CHECK(!(initial1 == different)); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK(!(shorter == initial1)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_not_equal) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + const DataNDC initial1(initial_data.begin(), initial_data.end(), lookup1, pool1); + const DataNDC initial2(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK(!(initial1 != initial2)); + + const DataNDC different(different_data.begin(), different_data.end(), lookup3, pool3); + + CHECK(initial1 != different); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK(shorter != initial1); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_less_than) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + const DataNDC less(less_data.begin(), less_data.end(), lookup1, pool1); + const DataNDC initial(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK((less < initial) == (less_data < initial_data)); + + const DataNDC greater(greater_data.begin(), greater_data.end(), lookup3, pool3); + + CHECK((greater < initial) == (greater_data < initial_data)); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK((shorter < initial) == (shorter_data < initial_data)); + CHECK((initial < shorter) == (initial_data < shorter_data)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_less_than_or_equal) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + LookupNDC lookup5; + PoolNDC pool5; + + const DataNDC less(less_data.begin(), less_data.end(), lookup1, pool1); + const DataNDC initial(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK((less <= initial) == (less_data <= initial_data)); + + const DataNDC greater(greater_data.begin(), greater_data.end(), lookup3, pool3); + + CHECK((greater <= initial) == (greater_data <= initial_data)); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK((shorter <= initial) == (shorter_data <= initial_data)); + CHECK((initial <= shorter) == (initial_data <= shorter_data)); + + const DataNDC initial2(initial_data.begin(), initial_data.end(), lookup5, pool5); + CHECK((initial <= initial2) == (initial_data <= initial_data)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_greater_than) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + const DataNDC less(less_data.begin(), less_data.end(), lookup1, pool1); + const DataNDC initial(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK((less > initial) == (less_data > initial_data)); + + const DataNDC greater(greater_data.begin(), greater_data.end(), lookup3, pool3); + + CHECK((greater > initial) == (greater_data > initial_data)); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK((shorter > initial) == (shorter_data > initial_data)); + CHECK((initial > shorter) == (initial_data > shorter_data)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_greater_than_or_equal) + { + LookupNDC lookup1; + PoolNDC pool1; + + LookupNDC lookup2; + PoolNDC pool2; + + LookupNDC lookup3; + PoolNDC pool3; + + LookupNDC lookup4; + PoolNDC pool4; + + LookupNDC lookup5; + PoolNDC pool5; + + const DataNDC less(less_data.begin(), less_data.end(), lookup1, pool1); + const DataNDC initial(initial_data.begin(), initial_data.end(), lookup2, pool2); + + CHECK((less >= initial) == (less_data >= initial_data)); + + const DataNDC greater(greater_data.begin(), greater_data.end(), lookup3, pool3); + + CHECK((greater >= initial) == (greater_data >= initial_data)); + + const DataNDC shorter(shorter_data.begin(), shorter_data.end(), lookup4, pool4); + + CHECK((shorter >= initial) == (shorter_data >= initial_data)); + CHECK((initial >= shorter) == (initial_data > shorter_data)); + + const DataNDC initial2(initial_data.begin(), initial_data.end(), lookup5, pool5); + CHECK((initial >= initial2) == (initial_data >= initial_data)); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_order_from_unordered_std_sort) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + std::sort(data.begin(), data.end()); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.begin()); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_order_from_unordered_std_stable_sort) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + std::stable_sort(data.begin(), data.end()); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_default_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_order_from_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(ordered_data.begin(), ordered_data.end(), lookup, pool); + + data.sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.begin()); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_order_from_reverse_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(ordered_data.rbegin(), ordered_data.rend(), lookup, pool); + + data.sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.begin()); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.begin()); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_greater_order_from_reverse_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(ordered_data.rbegin(), ordered_data.rend(), lookup, pool); + + data.sort(std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.rbegin()); + + CHECK(is_equal); + CHECK(data.is_sorted(std::greater())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_greater_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.sort(std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + ordered_data.rbegin()); + + CHECK(is_equal); + CHECK(data.is_sorted(std::greater())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_default_partial_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.sort(data.begin() + 2, data.end() - 2); + + bool is_equal = std::equal(data.begin(), + data.end(), + part_ordered_data.begin()); + + CHECK(is_equal); + CHECK((data.is_sorted(data.cbegin() + 2, data.cend() - 2))); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_sort_greater_partial_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.sort(data.begin() + 2, data.end() - 2, std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + part_reverse_ordered_data.begin()); + + CHECK(is_equal); + CHECK((data.is_sorted(data.begin() + 2, data.end() - 2, std::greater()))); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_default_order_from_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(stable_default_ordered_data.begin(), stable_default_ordered_data.end(), lookup, pool); + + data.stable_sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_default_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_default_order_from_reverse_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(stable_default_ordered_data.rbegin(), stable_default_ordered_data.rend(), lookup, pool); + + data.stable_sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_reverse_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_default_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.stable_sort(); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_default_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted()); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_greater_order_from_reverse_ordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(stable_default_ordered_data.rbegin(), stable_default_ordered_data.rend(), lookup, pool); + + data.stable_sort(std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_greater_reverse_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted(std::greater())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_greater_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.stable_sort(std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_greater_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK(data.is_sorted(std::greater())); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_default_partial_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.stable_sort(data.begin() + 2, data.end() - 2); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_part_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK((data.is_sorted(data.cbegin() + 2, data.cend() - 2))); + } + + //************************************************************************* + TEST_FIXTURE(SetupFixture, test_stable_sort_greater_partial_order_from_unordered) + { + LookupNDC lookup; + PoolNDC pool; + + DataNDC data(unordered_data.begin(), unordered_data.end(), lookup, pool); + + data.stable_sort(data.begin() + 2, data.end() - 2, std::greater()); + + bool is_equal = std::equal(data.begin(), + data.end(), + stable_part_greater_ordered_data.begin(), + NDC::are_identical); + + CHECK(is_equal); + CHECK((data.is_sorted(data.begin() + 2, data.end() - 2, std::greater()))); + } + }; +} diff --git a/test/vs2017/etl.vcxproj b/test/vs2017/etl.vcxproj index 27457fc5..71eeb118 100644 --- a/test/vs2017/etl.vcxproj +++ b/test/vs2017/etl.vcxproj @@ -674,6 +674,7 @@ + diff --git a/test/vs2017/etl.vcxproj.filters b/test/vs2017/etl.vcxproj.filters index 86c4286f..45e32041 100644 --- a/test/vs2017/etl.vcxproj.filters +++ b/test/vs2017/etl.vcxproj.filters @@ -1247,6 +1247,9 @@ Source Files + + Source Files +