From e5a9fa312745e714dfead8efa68e0a27a2135dac Mon Sep 17 00:00:00 2001 From: jwellbelove Date: Wed, 19 Nov 2014 18:37:14 +0000 Subject: [PATCH] Updated tests --- test/test_bitset.cpp | 578 ++++++++ test/test_container.cpp | 16 +- test/test_crc.cpp | 303 +++- test/test_deque.cpp | 2553 ++++++++++++--------------------- test/test_integral_limits.cpp | 91 +- test/test_largest.cpp | 40 +- 6 files changed, 1866 insertions(+), 1715 deletions(-) create mode 100644 test/test_bitset.cpp diff --git a/test/test_bitset.cpp b/test/test_bitset.cpp new file mode 100644 index 00000000..d7d7c403 --- /dev/null +++ b/test/test_bitset.cpp @@ -0,0 +1,578 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. + +Copyright(c) 2014 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 + +#include +#include +#include + +#define ETL_IN_UNIT_TEST + +#include "../bitset.h" + +#undef min +#undef max + +namespace +{ + SUITE(TestBitset) + { + //************************************************************************* + TEST(test_constructor) + { + std::bitset<60> compare; + etl::bitset<60> data; + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_construct_from_value) + { + std::bitset<60> compare(0x123456731234567); + etl::bitset<60> data(0x123456731234567); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_construct_from_excess_value) + { + std::bitset<60> compare(0x8765432187654321); + etl::bitset<60> data(0x8765432187654321); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_construct_from_string) + { + std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001"); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_construct_from_excess_string) + { + std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001"); + etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001"); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_set) + { + std::bitset<60> compare; + etl::bitset<60> data; + + compare.set(); + data.set(); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_position_set) + { + std::bitset<60> compare; + etl::bitset<60> data; + + for (size_t i = 0; i < data.size(); ++i) + { + compare.set(i, true); + data.set(i++, true); + compare.set(i, false); + data.set(i, false); + } + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_reset) + { + std::bitset<60> compare(0xFFFFFFFFFFFFFFF); + etl::bitset<60> data(0xFFFFFFFFFFFFFFF); + + compare.reset(); + data.reset(); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_position_reset) + { + std::bitset<60> compare(0xFFFFFFFFFFFFFFF); + etl::bitset<60> data(0xFFFFFFFFFFFFFFF); + + for (size_t i = 0; i < data.size(); i += 2) + { + compare.reset(i); + data.reset(i); + } + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_index_operator_read) + { + std::bitset<60> compare(0x3123456731234567); + etl::bitset<60> data(0x3123456731234567); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare[i], data[i]); + } + } + + //************************************************************************* + TEST(test_index_operator_write) + { + std::bitset<60> compare; + etl::bitset<60> data; + + for (size_t i = 0; i < data.size(); ++i) + { + compare[i] = true; + data[i++] = true; + + compare[i] = false; + data[i] = false; + } + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare[i], data[i]); + } + } + + //************************************************************************* + TEST(test_any) + { + std::bitset<60> compare; + etl::bitset<60> data; + + // Set all bits + compare.set(); + data.set(); + + // Reset them all. + for (size_t i = 0; i < data.size(); ++i) + { + compare.reset(i); + data.reset(i); + } + + CHECK_EQUAL(compare.any(), data.any()); + + compare.set(3); + data.set(3); + + CHECK_EQUAL(compare.any(), data.any()); + } + + //************************************************************************* + TEST(test_none) + { + std::bitset<62> compare; + etl::bitset<62> data; + + CHECK_EQUAL(compare.none(), data.none()); + + compare.set(3); + data.set(3); + + CHECK_EQUAL(compare.none(), data.none()); + } + + //************************************************************************* + TEST(test_all) + { + std::bitset<60> compare; + etl::bitset<60> data; + + CHECK_EQUAL(compare.all(), data.all()); + + compare.set(); + data.set(); + + CHECK_EQUAL(compare.all(), data.all()); + } + + //************************************************************************* + TEST(test_flip) + { + std::bitset<60> compare; + etl::bitset<60> data; + + compare.flip(); + data.flip(); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_flip_position) + { + std::bitset<60> compare; + etl::bitset<60> data; + + compare.flip(3); + data.flip(3); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_flip_reference) + { + std::bitset<60> compare; + etl::bitset<60> data; + + compare[3].flip(); + data[3].flip(); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_invert_reference) + { + std::bitset<60> compare; + etl::bitset<60> data; + + bool bc = ~compare[3]; + bool bd = ~data[3]; + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_assignment_operator) + { + std::bitset<60> compare(0xFFFFFFFFFFFFFFF); + etl::bitset<60> data1(0xFFFFFFFFFFFFFFF); + etl::bitset<60> data2; + + data2 = data1; + + for (size_t i = 0; i < data2.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data2.test(i)); + } + } + + //************************************************************************* + TEST(test_equality_operator) + { + etl::bitset<60> data1(0x123456781234567); + etl::bitset<60> data2(0x123456781234567); + etl::bitset<60> data3; + + CHECK(data1 == data2); + CHECK(!(data1 == data3)); + } + + //************************************************************************* + TEST(test_inequality_operator) + { + etl::bitset<60> data1(0x123456781234567); + etl::bitset<60> data2(0x123456781234567); + etl::bitset<60> data3; + + CHECK(!(data1 != data2)); + CHECK(data1 != data3); + } + + //************************************************************************* + TEST(test_shift_left_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2; + etl::bitset<60> shift1(0x2468ACF0); + etl::bitset<60> shift2(0x48D159E0); + etl::bitset<60> shift11(0x91A2B3C000); + + data2 = data1; + data2 <<= 1; + CHECK(data2 == shift1); + + data2 = data1; + data2 <<= 2; + CHECK(data2 == shift2); + + data2 = data1; + data2 <<= 11; + CHECK(data2 == shift11); + } + + //************************************************************************* + TEST(test_shift_left_copy_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2; + etl::bitset<60> shift1(0x2468ACF0); + etl::bitset<60> shift2(0x48D159E0); + etl::bitset<60> shift11(0x91A2B3C000); + + data2 = data1 << 1; + CHECK(data2 == shift1); + + data2 = data1 << 2; + CHECK(data2 == shift2); + + data2 = data1 << 11; + CHECK(data2 == shift11); + } + + //************************************************************************* + TEST(test_shift_right_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2; + etl::bitset<60> shift1(0x91A2B3C); + etl::bitset<60> shift2(0x48D159E); + etl::bitset<60> shift11(0x2468A); + + data2 = data1; + data2 >>= 1; + CHECK(data2 == shift1); + + data2 = data1; + data2 >>= 2; + CHECK(data2 == shift2); + + data2 = data1; + data2 >>= 11; + CHECK(data2 == shift11); + } + + //************************************************************************* + TEST(test_shift_right_copy_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2; + etl::bitset<60> shift1(0x91A2B3C); + etl::bitset<60> shift2(0x48D159E); + etl::bitset<60> shift11(0x2468A); + + data2 = data1 >> 1; + CHECK(data2 == shift1); + + data2 = data1 >> 2; + CHECK(data2 == shift2); + + data2 = data1 >> 11; + CHECK(data2 == shift11); + } + + //************************************************************************* + TEST(test_and_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3; + etl::bitset<60> data4(0x12345678 & 0x23456789); + + data3 = data1 & data2; + CHECK(data3 == data4); + } + + //************************************************************************* + TEST(test_and_equals_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3(0x12345678 & 0x23456789); + + data2 &= data1; + CHECK(data2 == data3); + } + + //************************************************************************* + TEST(test_or_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3; + etl::bitset<60> data4(0x12345678 | 0x23456789); + + data3 = data1 | data2; + CHECK(data3 == data4); + } + + //************************************************************************* + TEST(test_or_equals_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3(0x12345678 | 0x23456789); + + data2 |= data1; + CHECK(data2 == data3); + } + + //************************************************************************* + TEST(test_xor_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3; + etl::bitset<60> data4(0x12345678 ^ 0x23456789); + + data3 = data1 ^ data2; + CHECK(data3 == data4); + } + + //************************************************************************* + TEST(test_xor_equals_operator) + { + etl::bitset<60> data1(0x12345678); + etl::bitset<60> data2(0x23456789); + etl::bitset<60> data3(0x12345678 ^ 0x23456789); + + data2 ^= data1; + CHECK(data2 == data3); + } + + //************************************************************************* + TEST(test_big_bitset) + { + std::bitset<1000000> compare; + etl::bitset<1000000> data; + + compare.flip(); + data.flip(); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_small_bitset) + { + std::bitset<7> compare; + etl::bitset<7> data; + + compare.flip(); + data.flip(); + + for (size_t i = 0; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + }; +} diff --git a/test/test_container.cpp b/test/test_container.cpp index 125c74a3..e7691e83 100644 --- a/test/test_container.cpp +++ b/test/test_container.cpp @@ -35,7 +35,7 @@ namespace SUITE(ContainerTest) { //************************************************************************* - TEST(TestSTLContainer) + TEST(test_stl_style_container) { const size_t SIZE = 10; std::list data(SIZE); @@ -48,7 +48,7 @@ namespace } //************************************************************************* - TEST(TestConstSTLContainer) + TEST(test_const_stl_style_container) { const size_t SIZE = 10; const std::list data(SIZE); @@ -61,7 +61,7 @@ namespace } //************************************************************************* - TEST(TestCArray) + TEST(test_c_array) { const size_t SIZE = 10; int data[SIZE]; @@ -74,7 +74,7 @@ namespace } //************************************************************************* - TEST(TestConstCArray) + TEST(test_const_c_array) { const size_t SIZE = 10; const int data[SIZE] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; @@ -88,7 +88,7 @@ namespace //************************************************************************* - TEST(TestNext) + TEST(test_next) { const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const int* p; @@ -104,7 +104,7 @@ namespace } //************************************************************************* - TEST(TestPrev) + TEST(test_prev) { const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const int* p; @@ -120,7 +120,7 @@ namespace } //************************************************************************* - TEST(TestSTLContainerSize) + TEST(test_stl_style_container_size) { const size_t SIZE = 10; std::list data(SIZE); @@ -130,7 +130,7 @@ namespace } //************************************************************************* - TEST(TestCArraySize) + TEST(test_c_array_size) { const size_t SIZE = 10; int data[SIZE]; diff --git a/test/test_crc.cpp b/test/test_crc.cpp index 23a058f8..abb16a14 100644 --- a/test/test_crc.cpp +++ b/test/test_crc.cpp @@ -28,77 +28,356 @@ SOFTWARE. #include #include +#include #include + #include "../crc8_ccitt.h" #include "../crc16.h" #include "../crc16_ccitt.h" #include "../crc16_kermit.h" #include "../crc32.h" #include "../crc64_ecma.h" +#include "../endian.h" namespace { SUITE(TestCRC) { //************************************************************************* - TEST(TestCRC8) + TEST(test_crc8_ccitt_constructor) { std::string data("123456789"); - uint8_t crc = etl::crc8_ccitt(data.begin(), data.end()); + uint8_t crc = etl::crc8_ccitt<>(data.begin(), data.end()); + + CHECK_EQUAL(0xF4, int(crc)); + } + + //************************************************************************* + TEST(test_crc8_ccitt_add_values) + { + std::string data("123456789"); + + etl::crc8_ccitt<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint8_t crc = crc_calculator; CHECK_EQUAL(0xF4, crc); } //************************************************************************* - TEST(TestCRC16) + TEST(test_crc8_ccitt_add_range) { std::string data("123456789"); - uint16_t crc = etl::crc16(data.begin(), data.end()); + etl::crc8_ccitt<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint8_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xF4, crc); + } + + //************************************************************************* + TEST(test_crc8_ccitt_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint8_t crc1 = etl::crc8_ccitt(data1.begin(), data1.end()); + uint8_t crc2 = etl::crc8_ccitt(data2.begin(), data2.end()); + CHECK_EQUAL(int(crc1), int(crc2)); + + uint8_t crc3 = etl::crc8_ccitt(data3.begin(), data3.end()); + CHECK_EQUAL(int(crc1), int(crc3)); + } + + //************************************************************************* + TEST(test_crc16) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16<>(data.begin(), data.end()); CHECK_EQUAL(0xBB3D, crc); } //************************************************************************* - TEST(TestCRC16CCITT) + TEST(test_crc16_add_values) { std::string data("123456789"); - uint16_t crc = etl::crc16_ccitt(data.begin(), data.end()); + etl::crc16<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0xBB3D, crc); + } + + //************************************************************************* + TEST(test_crc16_add_range) + { + std::string data("123456789"); + + etl::crc16<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xBB3D, crc); + } + + //************************************************************************* + TEST(test_crc16_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint16_t crc1 = etl::crc16(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16(data2.begin(), data2.end()); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16(data3.begin(), data3.end()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_ccitt) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_ccitt<>(data.begin(), data.end()); CHECK_EQUAL(0x29B1, crc); } //************************************************************************* - TEST(TestCRC16Kermit) + TEST(test_crc16_ccitt_add_values) { std::string data("123456789"); - uint16_t crc = etl::crc16_kermit(data.begin(), data.end()); + etl::crc16_ccitt<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0x29B1, crc); + } + + //************************************************************************* + TEST(test_crc16_ccitt_add_range) + { + std::string data("123456789"); + + etl::crc16_ccitt<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x29B1, crc); + } + + //************************************************************************* + TEST(test_crc16_ccitt_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint16_t crc1 = etl::crc16_ccitt(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_ccitt(data2.begin(), data2.end()); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_ccitt(data3.begin(), data3.end()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc16_kermit) + { + std::string data("123456789"); + + uint16_t crc = etl::crc16_kermit<>(data.begin(), data.end()); CHECK_EQUAL(0x2189, crc); } //************************************************************************* - TEST(TestCRC32) + TEST(test_crc16_kermit_add_values) { std::string data("123456789"); - uint32_t crc = etl::crc32(data.begin(), data.end()); + etl::crc16_kermit<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint16_t crc = crc_calculator; + + CHECK_EQUAL(0x2189, crc); + } + + //************************************************************************* + TEST(test_crc16_kermit_add_range) + { + std::string data("123456789"); + + etl::crc16_kermit<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint16_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x2189, crc); + } + + //************************************************************************* + TEST(test_crc16_kermit_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint16_t crc1 = etl::crc16_kermit(data1.begin(), data1.end()); + uint16_t crc2 = etl::crc16_kermit(data2.begin(), data2.end()); + CHECK_EQUAL(crc1, crc2); + + uint16_t crc3 = etl::crc16_kermit(data3.begin(), data3.end()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc32) + { + std::string data("123456789"); + + uint32_t crc = etl::crc32<>(data.begin(), data.end()); CHECK_EQUAL(0xCBF43926, crc); } //************************************************************************* - TEST(TestCRC64ECMA) + TEST(test_crc32_add_values) { std::string data("123456789"); - uint64_t crc = etl::crc64_ecma(data.begin(), data.end()); + etl::crc32<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint32_t crc = crc_calculator; + + CHECK_EQUAL(0xCBF43926, crc); + } + + //************************************************************************* + TEST(test_crc32_add_range) + { + std::string data("123456789"); + + etl::crc32<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint32_t crc = crc_calculator.value(); + + CHECK_EQUAL(0xCBF43926, crc); + } + + //************************************************************************* + TEST(test_crc32_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint32_t crc1 = etl::crc32(data1.begin(), data1.end()); + uint32_t crc2 = etl::crc32(data2.begin(), data2.end()); + CHECK_EQUAL(crc1, crc2); + + uint32_t crc3 = etl::crc32(data3.begin(), data3.end()); + CHECK_EQUAL(crc1, crc3); + } + + //************************************************************************* + TEST(test_crc64_ecma) + { + std::string data("123456789"); + + uint64_t crc = etl::crc64_ecma<>(data.begin(), data.end()); CHECK_EQUAL(0x6C40DF5F0B497347, crc); } + + //************************************************************************* + TEST(test_crc64_ecma_add_values) + { + std::string data("123456789"); + + etl::crc64_ecma<> crc_calculator; + + for (size_t i = 0; i < data.size(); ++i) + { + crc_calculator += data[i]; + } + + uint64_t crc = crc_calculator; + + CHECK_EQUAL(0x6C40DF5F0B497347, crc); + } + + //************************************************************************* + TEST(test_crc64_ecma_add_range) + { + std::string data("123456789"); + + etl::crc64_ecma<> crc_calculator; + + crc_calculator.add(data.begin(), data.end()); + + uint64_t crc = crc_calculator.value(); + + CHECK_EQUAL(0x6C40DF5F0B497347, crc); + } + + //************************************************************************* + TEST(test_crc64_ecma_add_range_endian) + { + std::vector data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; + std::vector data2 = { 0x04030201, 0x08070605 }; + std::vector data3 = { 0x01020304, 0x05060708 }; + + uint64_t crc1 = etl::crc64_ecma(data1.begin(), data1.end()); + uint64_t crc2 = etl::crc64_ecma(data2.begin(), data2.end()); + CHECK_EQUAL(crc1, crc2); + + uint64_t crc3 = etl::crc64_ecma(data3.begin(), data3.end()); + CHECK_EQUAL(crc1, crc3); + } }; } diff --git a/test/test_deque.cpp b/test/test_deque.cpp index ee4ef6b1..8aff7307 100644 --- a/test/test_deque.cpp +++ b/test/test_deque.cpp @@ -34,14 +34,14 @@ SOFTWARE. const size_t SIZE = 6; typedef etl::deque Data; -typedef std::vector CompareData; +typedef std::vector Compare_Data; -namespace FixedDequeTest +namespace { - SUITE(TestDeque) + SUITE(test_deque) { //************************************************************************* - TEST(Contruct) + TEST(test_constructor) { Data data; @@ -50,9 +50,9 @@ namespace FixedDequeTest } //************************************************************************* - TEST(ContructFill) + TEST(test_constructor_fill) { - CompareData compare_data = { 5, 5, 5, 5, 5, 5}; + Compare_Data compare_data = { 5, 5, 5, 5, 5, 5}; Data data(SIZE, 5); CHECK_EQUAL(compare_data.size(), data.size()); @@ -60,15 +60,15 @@ namespace FixedDequeTest } //************************************************************************* - TEST(ContructFillExcess) + TEST(test_constructor_fill_excess) { CHECK_THROW(Data(SIZE + 1, 5), etl::deque_full); } //************************************************************************* - TEST(ContructRange) + TEST(test_constructor_range) { - CompareData compare_data = { 1, 2, 3, 4, 5 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; Data data(compare_data.begin(), compare_data.end()); CHECK_EQUAL(compare_data.size(), data.size()); @@ -76,86 +76,44 @@ namespace FixedDequeTest } //************************************************************************* - TEST(ContructRangeExcess) + TEST(test_constructor_range_excess) { - CompareData compare_data = { 1, 2, 3, 4, 5, 6, 7 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5, 6, 7 }; CHECK_THROW(Data data(compare_data.begin(), compare_data.end()), etl::deque_full); } //************************************************************************* - TEST(CopyContruct) + TEST(test_copy_constructor) { - CompareData original = { 1, 2, 3, 4, 5, 6 }; - CompareData modified = { 6, 5, 4, 3, 2, 1 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5, 6 }; + Compare_Data modified = { 6, 5, 4, 3, 2, 1 }; - Data testDeque1(original.begin(), original.end()); - Data testDeque2(testDeque1); + Data deque1(compare_data.begin(), compare_data.end()); + Data deque2(deque1); - CHECK_EQUAL(testDeque1.size(), testDeque2.size()); - CHECK(std::equal(original.begin(), original.end(), testDeque2.begin())); - - // Change testDeque2's data. - std::copy(modified.begin(), modified.end(), testDeque2.begin()); - CHECK(std::equal(original.begin(), original.end(), testDeque1.begin())); - CHECK(std::equal(modified.begin(), modified.end(), testDeque2.begin())); + CHECK_EQUAL(deque1.size(), deque2.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end(), deque2.begin())); } //************************************************************************* - TEST(Assignment) + TEST(test_assignment) { - CompareData original = { 1, 2, 3, 4, 5, 6 }; - CompareData modified = { 6, 5, 4, 3, 2, 1 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5, 6 }; - Data testDeque1(original.begin(), original.end()); - Data testDeque2; + Data deque1(compare_data.begin(), compare_data.end()); + Data deque2; - testDeque2 = testDeque1; + deque2 = deque1; - CHECK_EQUAL(testDeque1.size(), testDeque2.size()); - CHECK(std::equal(original.begin(), original.end(), testDeque2.begin())); - - // Change testDeque2's data. - std::copy(modified.begin(), modified.end(), testDeque2.begin()); - CHECK(std::equal(original.begin(), original.end(), testDeque1.begin())); - CHECK(std::equal(modified.begin(), modified.end(), testDeque2.begin())); + CHECK_EQUAL(deque1.size(), deque2.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end(), deque2.begin())); } //************************************************************************* - TEST(Swap) - { - CompareData compare_data1 = { 1, 2, 3, 4, 5, 6 }; - CompareData compare_data2 = { 6, 5, 4 }; - - Data data1(compare_data1.begin(), compare_data1.end()); - Data data2(compare_data2.begin(), compare_data2.end()); - - swap(data1, data2); - - CHECK_EQUAL(compare_data2.size(), data1.size()); - CHECK_EQUAL(compare_data1.size(), data2.size()); - - CHECK_EQUAL(std::distance(compare_data2.begin(), compare_data2.end()), std::distance(data1.begin(), data1.end())); - CHECK_EQUAL(std::distance(compare_data1.begin(), compare_data1.end()), std::distance(data2.begin(), data2.end())); - - CHECK(std::equal(compare_data2.begin(), compare_data2.end(), data1.begin())); - CHECK(std::equal(compare_data1.begin(), compare_data1.end(), data2.begin())); - } - - //************************************************************************* - TEST(Clear) + TEST(test_assign_range) { - Data data; - - data.resize(SIZE); - data.clear(); - CHECK(data.empty()); - } - - //************************************************************************* - TEST(AssignFromRange) - { - CompareData compare_data = { 1, 2, 3, 4, 5 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; Data data; CHECK_NO_THROW(data.assign(compare_data.begin(), compare_data.end())); @@ -165,18 +123,18 @@ namespace FixedDequeTest } //************************************************************************* - TEST(AssignFromRangeExcess) + TEST(test_assign_range_excess) { - CompareData compare_data = { 1, 2, 3, 4, 5, 6, 7 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5, 6, 7 }; Data data; CHECK_THROW(data.assign(compare_data.begin(), compare_data.end()), etl::deque_full); } //************************************************************************* - TEST(AssignFill) + TEST(test_assign_fill) { - CompareData compare_data = { 5, 5, 5, 5, 5, 5 }; + Compare_Data compare_data = { 5, 5, 5, 5, 5, 5 }; Data data; @@ -187,7 +145,7 @@ namespace FixedDequeTest } //************************************************************************* - TEST(AssignFillExcess) + TEST(test_assign_fill_excess) { Data data; @@ -195,9 +153,747 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushBackNoValue) + TEST(test_at) { - CompareData compare_data = { 1, 2, 3, 4, 5 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + CHECK_EQUAL(compare_data[0], data.at(0)); + CHECK_EQUAL(compare_data[1], data.at(1)); + CHECK_EQUAL(compare_data[2], data.at(2)); + CHECK_EQUAL(compare_data[3], data.at(3)); + CHECK_EQUAL(compare_data[4], data.at(4)); + } + + //************************************************************************* + TEST(test_at_const) + { + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + const Data& cdata(data); + + CHECK_EQUAL(compare_data[0], cdata.at(0)); + CHECK_EQUAL(compare_data[1], cdata.at(1)); + CHECK_EQUAL(compare_data[2], cdata.at(2)); + CHECK_EQUAL(compare_data[3], cdata.at(3)); + CHECK_EQUAL(compare_data[4], cdata.at(4)); + } + + //************************************************************************* + TEST(test_index_operator) + { + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + CHECK_EQUAL(compare_data[0], data[0]); + CHECK_EQUAL(compare_data[1], data[1]); + CHECK_EQUAL(compare_data[2], data[2]); + CHECK_EQUAL(compare_data[3], data[3]); + CHECK_EQUAL(compare_data[4], data[4]); + } + + //************************************************************************* + TEST(test_index_operator_const) + { + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + const Data& ctestDeque(data); + + CHECK_EQUAL(compare_data[0], ctestDeque[0]); + CHECK_EQUAL(compare_data[1], ctestDeque[1]); + CHECK_EQUAL(compare_data[2], ctestDeque[2]); + CHECK_EQUAL(compare_data[3], ctestDeque[3]); + CHECK_EQUAL(compare_data[4], ctestDeque[4]); + } + + //************************************************************************* + TEST(test_front) + { + Data data; + + data.push_front(1); + CHECK_EQUAL(1, data.front()); + + data.push_front(2); + CHECK_EQUAL(2, data.front()); + + data.push_front(3); + CHECK_EQUAL(3, data.front()); + + data.push_front(4); + CHECK_EQUAL(4, data.front()); + + data.push_front(5); + CHECK_EQUAL(5, data.front()); + } + + //************************************************************************* + TEST(test_front_empty) + { + Data data; + + CHECK_THROW(int i = data.front(), etl::deque_empty); + } + + //************************************************************************* + TEST(test_front_const) + { + Data data; + const Data& ctestDeque = data; + + data.push_front(1); + CHECK_EQUAL(1, ctestDeque.front()); + + data.push_front(2); + CHECK_EQUAL(2, ctestDeque.front()); + + data.push_front(3); + CHECK_EQUAL(3, ctestDeque.front()); + + data.push_front(4); + CHECK_EQUAL(4, ctestDeque.front()); + + data.push_front(5); + CHECK_EQUAL(5, ctestDeque.front()); + } + + //************************************************************************* + TEST(test_back) + { + Data data; + + data.push_back(1); + CHECK_EQUAL(1, data.back()); + + data.push_back(2); + CHECK_EQUAL(2, data.back()); + + data.push_back(3); + CHECK_EQUAL(3, data.back()); + + data.push_back(4); + CHECK_EQUAL(4, data.back()); + + data.push_back(5); + CHECK_EQUAL(5, data.back()); + } + + //************************************************************************* + TEST(test_back_const) + { + Data data; + const Data& ctestDeque = data; + + data.push_back(1); + CHECK_EQUAL(1, ctestDeque.back()); + + data.push_back(2); + CHECK_EQUAL(2, ctestDeque.back()); + + data.push_back(3); + CHECK_EQUAL(3, ctestDeque.back()); + + data.push_back(4); + CHECK_EQUAL(4, ctestDeque.back()); + + data.push_back(5); + CHECK_EQUAL(5, ctestDeque.back()); + } + + //************************************************************************* + TEST(test_back_empty) + { + Data data; + + CHECK_THROW(int i = data.back(), etl::deque_empty); + } + + //************************************************************************* + TEST(test_iterator_comparison) + { + Data data(6, 0); + + Data::iterator first = data.begin() + 1; + Data::iterator second = data.begin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_iterator_comparison) + { + Data data(6, 0); + + Data::const_iterator first = data.cbegin() + 1; + Data::const_iterator second = data.cbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_iterator_comparison_rollover_left) + { + Data data(6, 0); + + data.pop_back(); + data.pop_back(); + data.pop_back(); + data.push_front(1); + data.push_front(1); + data.push_front(1); + + Data::const_iterator first = data.cbegin() + 1; + Data::const_iterator second = data.cbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_iterator_comparison_rollover_left) + { + Data data(6, 0); + + data.pop_back(); + data.pop_back(); + data.pop_back(); + data.push_front(1); + data.push_front(1); + data.push_front(1); + + Data::const_iterator first = data.cbegin() + 1; + Data::const_iterator second = data.cbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_iterator_comparison_rollover_right) + { + Data data(6, 0); + + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); + data.push_back(1); + data.push_back(1); + + Data::iterator first = data.begin() + 1; + Data::iterator second = data.begin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_iterator_comparison_rollover_right) + { + Data data(6, 0); + + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); + data.push_back(1); + data.push_back(1); + + Data::const_iterator first = data.cbegin() + 1; + Data::const_iterator second = data.cbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_reverse_iterator_comparison) + { + Data data(6, 0); + + Data::reverse_iterator first = data.rbegin() + 1; + Data::reverse_iterator second = data.rbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_reverse_iterator_comparison) + { + Data data(6, 0); + + Data::const_reverse_iterator first = data.crbegin() + 1; + Data::const_reverse_iterator second = data.crbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_reverse_iterator_comparison_rollover_left) + { + Data data(6, 0); + + data.pop_back(); + data.pop_back(); + data.pop_back(); + data.push_front(1); + data.push_front(1); + data.push_front(1); + + Data::reverse_iterator first = data.rbegin() + 1; + Data::reverse_iterator second = data.rbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_reverse_iterator_comparison_rollover_left) + { + Data data(6, 0); + + data.pop_back(); + data.pop_back(); + data.pop_back(); + data.push_front(1); + data.push_front(1); + data.push_front(1); + + Data::const_reverse_iterator first = data.crbegin() + 1; + Data::const_reverse_iterator second = data.crbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_reverse_iterator_comparison_rollover_right) + { + Data data(6, 0); + + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); + data.push_back(1); + data.push_back(1); + + Data::reverse_iterator first = data.rbegin() + 1; + Data::reverse_iterator second = data.rbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_const_reverse_iterator_comparison_rollover_right) + { + Data data(6, 0); + + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); + data.push_back(1); + data.push_back(1); + + Data::const_reverse_iterator first = data.crbegin() + 1; + Data::const_reverse_iterator second = data.crbegin() + 4; + + CHECK(first < second); + CHECK(!(second < first)); + } + + //************************************************************************* + TEST(test_empty) + { + Data data; + + CHECK(data.empty()); + } + + //************************************************************************* + TEST(test_full) + { + Data data; + data.resize(SIZE); + + CHECK(data.full()); + } + + //************************************************************************* + TEST(test_clear) + { + Data data; + + data.resize(SIZE); + data.clear(); + CHECK(data.empty()); + } + + //************************************************************************* + TEST(test_insert_value_begin) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data expected = { 5, 1, 2, 3, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin(), 5); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(0, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_value_end) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data expected = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.end(), 5); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(4, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_value_middle) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data expected1 = { 1, 5, 2, 3, 4 }; + Compare_Data expected2 = { 1, 2, 5, 3, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin() + 1, 5); + + CHECK_EQUAL(expected1.size(), data.size()); + CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); + CHECK_EQUAL(1, std::distance(data.begin(), position)); + + data.assign(compare_data.begin(), compare_data.end()); + + position = data.insert(data.begin() + 2, 5); + + CHECK_EQUAL(expected2.size(), data.size()); + CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); + CHECK_EQUAL(2, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_n_value_begin) + { + Compare_Data compare_data = { 1, 2, 3 }; + Compare_Data expected = { 5, 5, 1, 2, 3 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin(), 2, 5); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(0, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_n_value_end) + { + Compare_Data compare_data = { 1, 2, 3 }; + Compare_Data expected = { 1, 2, 3, 5, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.end(), 2, 5); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(3, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_n_value_middle) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data expected1 = { 1, 5, 5, 2, 3, 4 }; + Compare_Data expected2 = { 1, 2, 3, 5, 5, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin() + 1, 2, 5); + + CHECK_EQUAL(expected1.size(), data.size()); + CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); + CHECK_EQUAL(1, std::distance(data.begin(), position)); + + data.assign(data.max_size(), -1); + data.assign(compare_data.begin(), compare_data.end()); + + position = data.insert(data.begin() + 3, 2, 5); + + CHECK_EQUAL(expected2.size(), data.size()); + CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); + CHECK_EQUAL(3, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_n_value_excess) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + CHECK_THROW(data.insert(data.begin(), 3, 5), etl::deque_full); + CHECK_THROW(data.insert(data.end(), 3, 5), etl::deque_full); + CHECK_THROW(data.insert(data.begin() + 2, 3, 5), etl::deque_full); + } + + //************************************************************************* + TEST(test_insert_range_begin) + { + Compare_Data compare_data = { 1, 2, 3 }; + Compare_Data range = { 4, 5 }; + Compare_Data expected = { 4, 5, 1, 2, 3 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin(), range.begin(), range.end()); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + } + + //************************************************************************* + TEST(test_insert_range_end) + { + Compare_Data compare_data = { 1, 2, 3 }; + Compare_Data range = { 4, 5 }; + Compare_Data expected = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.end(), range.cbegin(), range.cend()); + + CHECK_EQUAL(expected.size(), data.size()); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + } + + //************************************************************************* + TEST(test_insert_range_middle) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data range = { 5, 6 }; + Compare_Data expected1 = { 1, 5, 6, 2, 3, 4 }; + Compare_Data expected2 = { 1, 2, 3, 5, 6, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + Data::iterator position = data.insert(data.begin() + 1, range.begin(), range.end()); + + CHECK_EQUAL(expected1.size(), data.size()); + CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); + CHECK_EQUAL(1, std::distance(data.begin(), position)); + + data.assign(compare_data.begin(), compare_data.end()); + + position = data.insert(data.begin() + 3, range.begin(), range.end()); + + CHECK_EQUAL(expected2.size(), data.size()); + CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); + CHECK_EQUAL(3, std::distance(data.begin(), position)); + } + + //************************************************************************* + TEST(test_insert_range_excess) + { + Compare_Data compare_data = { 1, 2, 3, 4 }; + Compare_Data range = { 5, 6, 7 }; + Data data(compare_data.begin(), compare_data.end()); + + CHECK_THROW(data.insert(data.begin(), range.begin(), range.end()), etl::deque_full); + CHECK_THROW(data.insert(data.end(), range.begin(), range.end()), etl::deque_full); + CHECK_THROW(data.insert(data.begin() + 2, range.begin(), range.end()), etl::deque_full); + } + + //************************************************************************* + TEST(test_erase_begin) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected = { 2, 3, 4, 5, 6 }; + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + Data::iterator i_next = data.erase(data.begin()); + + CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.begin().get_index()); + } + + //************************************************************************* + TEST(test_erase_end) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected = { 1, 2, 3, 4, 5 }; + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + Data::iterator i_erase = data.end() - 1; + Data::iterator i_next = data.erase(i_erase); + + CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.end().get_index()); + } + + //************************************************************************* + TEST(test_erase_middle) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected1 = { 1, 3, 4, 5, 6 }; + Compare_Data expected2 = { 1, 2, 3, 4, 6 }; + + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + // Erase near beginning. + Data::iterator i_erase = data.begin() + 1; + Data::iterator i_next = data.erase(i_erase); + + CHECK_EQUAL(Data::difference_type(expected1.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.begin().get_index() + 1); + + data.assign(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + // Erase near end. + i_next = data.erase(data.begin() + 4); + + CHECK_EQUAL(Data::difference_type(expected2.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.begin().get_index() + 4); + } + + //************************************************************************* + TEST(test_erase_range_begin) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected = { 3, 4, 5, 6 }; + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + Data::iterator i_next = data.erase(data.begin(), data.begin() + 2); + + CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.begin().get_index()); + } + + //************************************************************************* + TEST(test_erase_range_end) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected = { 1, 2, 3, 4 }; + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + Data::iterator i_next = data.erase(data.end() - 2, data.end()); + + CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected.begin(), expected.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), data.end().get_index()); + } + + //************************************************************************* + TEST(test_erase_range_middle) + { + Compare_Data compare_data = { 0, 0, 1, 2, 3, 4 }; + Compare_Data expected1 = { 1, 4, 5, 6 }; + Compare_Data expected2 = { 1, 2, 3, 6 }; + + Data data(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + Data::iterator i_next = data.erase(data.begin() + 1, data.begin() + 3); + + CHECK_EQUAL(Data::difference_type(expected1.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), (data.begin() + 1).get_index()); + + data.assign(compare_data.begin(), compare_data.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.push_back(5); + data.push_back(6); + + i_next = data.erase(data.begin() + 3, data.begin() + 5); + + CHECK_EQUAL(Data::difference_type(expected2.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), (data.begin() + 3).get_index()); + + Compare_Data original2 = { 0, 0, 0, 0, 1, 2 }; + Compare_Data expected3 = { 1, 2, 5, 6 }; + + data.assign(original2.begin(), original2.end()); + + // Cause rollover. + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(3); + data.push_back(4); + data.push_back(5); + data.push_back(6); + + i_next = data.erase(data.begin() + 2, data.begin() + 4); + + CHECK_EQUAL(Data::difference_type(expected3.size()), std::distance(data.begin(), data.end())); + CHECK(std::equal(expected3.begin(), expected3.end(), data.begin())); + CHECK_EQUAL(i_next.get_index(), (data.begin() + 2).get_index()); + } + + //************************************************************************* + TEST(test_push_back_null) + { + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; Data data; CHECK_NO_THROW(data.push_back()); @@ -224,9 +920,9 @@ namespace FixedDequeTest } //************************************************************************* - TEST(push_back) + TEST(test_push_back) { - CompareData compare_data = { 1, 2, 3, 4, 5}; + Compare_Data compare_data = { 1, 2, 3, 4, 5}; Data data; CHECK_NO_THROW(data.push_back(1)); @@ -251,7 +947,7 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushBackExcess) + TEST(test_push_back_excess) { Data data; @@ -265,9 +961,37 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushFrontNoValue) + TEST(test_pop_back) { - CompareData compare_data = {5, 4, 3, 2, 1 }; + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; + Data data; + + data.assign(compare_data.begin(), compare_data.end()); + + data.pop_back(); + CHECK_EQUAL(size_t(4), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end() - 1, data.begin())); + + data.pop_back(); + CHECK_EQUAL(size_t(3), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end() - 2, data.begin())); + + data.pop_back(); + CHECK_EQUAL(size_t(2), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end() - 3, data.begin())); + + data.pop_back(); + CHECK_EQUAL(size_t(1), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end() - 4, data.begin())); + + data.pop_back(); + CHECK_EQUAL(size_t(0), data.size()); + } + + //************************************************************************* + TEST(test_push_front_null) + { + Compare_Data compare_data = {5, 4, 3, 2, 1 }; Data data; CHECK_NO_THROW(data.push_front()); @@ -294,9 +1018,9 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushFront) + TEST(test_push_front) { - CompareData compare_data = { 5, 4, 3, 2, 1 }; + Compare_Data compare_data = { 5, 4, 3, 2, 1 }; Data data; CHECK_NO_THROW(data.push_front(1)); @@ -321,7 +1045,7 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushFrontExcess) + TEST(test_push_front_excess) { Data data; @@ -334,9 +1058,9 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PushFrontPushBack) + TEST(test_push_front_push_back) { - CompareData compare_data = { 1, 2, 3, 4, 5}; + Compare_Data compare_data = { 1, 2, 3, 4, 5}; Data data; CHECK_NO_THROW(data.push_back(3)); @@ -349,9 +1073,32 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PopFront) + TEST(test_push_back_pop_front_push_back) { - CompareData compare_data = { 1, 2, 3, 4, 5 }; + Compare_Data compare_data = { 6, 7, 8 }; + Data data; + + data.push_back(1); + data.push_back(2); + data.push_back(3); + data.push_back(4); + data.push_back(5); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(6); + data.push_back(7); + data.push_back(8); + + CHECK(std::equal(compare_data.begin(), compare_data.end(), data.begin())); + } + + //************************************************************************* + TEST(test_pop_front) + { + Compare_Data compare_data = { 1, 2, 3, 4, 5 }; Data data; data.assign(compare_data.begin(), compare_data.end()); @@ -377,40 +1124,21 @@ namespace FixedDequeTest } //************************************************************************* - TEST(PopBack) + TEST(test_resize_up) { - CompareData compare_data = { 1, 2, 3, 4, 5 }; + Compare_Data compare_data = { 1, 2, 0, 0, 0 }; Data data; - data.assign(compare_data.begin(), compare_data.end()); - - data.pop_back(); - CHECK_EQUAL(size_t(4), data.size()); - CHECK(std::equal(compare_data.begin(), compare_data.end() - 1, data.begin())); - - data.pop_back(); - CHECK_EQUAL(size_t(3), data.size()); - CHECK(std::equal(compare_data.begin(), compare_data.end() - 2, data.begin())); - - data.pop_back(); - CHECK_EQUAL(size_t(2), data.size()); - CHECK(std::equal(compare_data.begin(), compare_data.end() - 3, data.begin())); - - data.pop_back(); - CHECK_EQUAL(size_t(1), data.size()); - CHECK(std::equal(compare_data.begin(), compare_data.end() - 4, data.begin())); - - data.pop_back(); - CHECK_EQUAL(size_t(0), data.size()); - } - - //************************************************************************* - TEST(Resize) - { - CompareData compare_data = { 1, 2, 0, 0, 0 }; - Data data; - - data.push_front(1); + // Cause rollover. + data.push_back(0); + data.push_back(0); + data.push_back(0); + data.push_back(0); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); data.push_back(2); data.resize(SIZE); @@ -419,9 +1147,34 @@ namespace FixedDequeTest } //************************************************************************* - TEST(ResizeWithValue) + TEST(test_resize_down) { - CompareData compare_data = { 1, 2, 3, 3, 3 }; + Compare_Data compare_data = { 1, 2 }; + Data data; + + // Cause rollover. + data.push_back(0); + data.push_back(0); + data.push_back(0); + data.pop_front(); + data.pop_front(); + data.pop_front(); + data.push_back(1); + data.push_back(2); + data.push_back(3); + data.push_back(4); + data.push_back(5); + data.push_back(6); + data.resize(data.size() - 4); + + CHECK_EQUAL(size_t(2), data.size()); + CHECK(std::equal(compare_data.begin(), compare_data.end(), data.begin())); + } + + //************************************************************************* + TEST(test_resize_value) + { + Compare_Data compare_data = { 1, 2, 3, 3, 3 }; Data data; data.push_front(1); @@ -433,7 +1186,7 @@ namespace FixedDequeTest } //************************************************************************* - TEST(ResizeExcess) + TEST(test_resize_excess) { Data data; @@ -441,1538 +1194,58 @@ namespace FixedDequeTest } //************************************************************************* - TEST(Full) + TEST(test_swap) { - Data data; - data.resize(SIZE); + Compare_Data compare_data1 = { 1, 2, 3, 4, 5, 6 }; + Compare_Data compare_data2 = { 6, 5, 4 }; - CHECK(data.full()); - } - - //************************************************************************* - TEST(empty) - { - Data data; - - CHECK(data.empty()); - } - - //************************************************************************* - TEST(Front) - { - Data data; - - data.push_front(1); - CHECK_EQUAL(1, data.front()); - - data.push_front(2); - CHECK_EQUAL(2, data.front()); - - data.push_front(3); - CHECK_EQUAL(3, data.front()); - - data.push_front(4); - CHECK_EQUAL(4, data.front()); - - data.push_front(5); - CHECK_EQUAL(5, data.front()); - } - - //************************************************************************* - TEST(FrontEmpty) - { - Data data; - - CHECK_THROW(int i = data.front(), etl::deque_empty); - } - - //************************************************************************* - TEST(FrontConst) - { - Data data; - const Data& ctestDeque = data; - - data.push_front(1); - CHECK_EQUAL(1, ctestDeque.front()); - - data.push_front(2); - CHECK_EQUAL(2, ctestDeque.front()); - - data.push_front(3); - CHECK_EQUAL(3, ctestDeque.front()); - - data.push_front(4); - CHECK_EQUAL(4, ctestDeque.front()); - - data.push_front(5); - CHECK_EQUAL(5, ctestDeque.front()); - } - - //************************************************************************* - TEST(Back) - { - Data data; - - data.push_back(1); - CHECK_EQUAL(1, data.back()); - - data.push_back(2); - CHECK_EQUAL(2, data.back()); - - data.push_back(3); - CHECK_EQUAL(3, data.back()); - - data.push_back(4); - CHECK_EQUAL(4, data.back()); - - data.push_back(5); - CHECK_EQUAL(5, data.back()); - } - - //************************************************************************* - TEST(BackConst) - { - Data data; - const Data& ctestDeque = data; - - data.push_back(1); - CHECK_EQUAL(1, ctestDeque.back()); - - data.push_back(2); - CHECK_EQUAL(2, ctestDeque.back()); - - data.push_back(3); - CHECK_EQUAL(3, ctestDeque.back()); - - data.push_back(4); - CHECK_EQUAL(4, ctestDeque.back()); - - data.push_back(5); - CHECK_EQUAL(5, ctestDeque.back()); - } - - //************************************************************************* - TEST(BackEmpty) - { - Data data; - - CHECK_THROW(int i = data.back(), etl::deque_empty); - } - - //************************************************************************* - TEST(Index) - { - CompareData compare_data = { 1, 2, 3, 4, 5 }; - Data data(compare_data.begin(), compare_data.end()); - - CHECK_EQUAL(compare_data[0], data[0]); - CHECK_EQUAL(compare_data[1], data[1]); - CHECK_EQUAL(compare_data[2], data[2]); - CHECK_EQUAL(compare_data[3], data[3]); - CHECK_EQUAL(compare_data[4], data[4]); - } - - //************************************************************************* - TEST(IndexOutOfRange) - { - CompareData compare_data = { 1, 2, 3, 4, 5 }; - Data data(compare_data.begin(), compare_data.end()); - - CHECK_THROW(int i = data[5], etl::deque_out_of_bounds); - } - - //************************************************************************* - TEST(IndexConst) - { - CompareData compare_data = { 1, 2, 3, 4, 5 }; - Data data(compare_data.begin(), compare_data.end()); - const Data& ctestDeque(data); - - CHECK_EQUAL(compare_data[0], ctestDeque[0]); - CHECK_EQUAL(compare_data[1], ctestDeque[1]); - CHECK_EQUAL(compare_data[2], ctestDeque[2]); - CHECK_EQUAL(compare_data[3], ctestDeque[3]); - CHECK_EQUAL(compare_data[4], ctestDeque[4]); - } - - //************************************************************************* - TEST(IndexConstOutOfRange) - { - CompareData compare_data = { 1, 2, 3, 4, 5 }; - Data data(compare_data.begin(), compare_data.end()); - const Data& ctestDeque(data); - - CHECK_THROW(int i = ctestDeque[5], etl::deque_out_of_bounds); - } - - //************************************************************************* - TEST(InsertValueBegin) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData expected = { 5, 1, 2, 3, 4 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin(), 5); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(0, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertValueEnd) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData expected = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.end(), 5); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(4, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertValueMiddle) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData expected1 = { 1, 5, 2, 3, 4 }; - CompareData expected2 = { 1, 2, 5, 3, 4 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin() + 1, 5); - - CHECK_EQUAL(expected1.size(), data.size()); - CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); - CHECK_EQUAL(1, std::distance(data.begin(), position)); - - data.assign(original.begin(), original.end()); - - position = data.insert(data.begin() + 2, 5); - - CHECK_EQUAL(expected2.size(), data.size()); - CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); - CHECK_EQUAL(2, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertNValueBegin) - { - CompareData original = { 1, 2, 3 }; - CompareData expected = { 5, 5, 1, 2, 3 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin(), 2, 5); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(0, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertNValueEnd) - { - CompareData original = { 1, 2, 3 }; - CompareData expected = { 1, 2, 3, 5, 5 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.end(), 2, 5); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(3, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertNValueMiddle) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData expected1 = { 1, 5, 5, 2, 3, 4 }; - CompareData expected2 = { 1, 2, 3, 5, 5, 4 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin() + 1, 2, 5); - - CHECK_EQUAL(expected1.size(), data.size()); - CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); - CHECK_EQUAL(1, std::distance(data.begin(), position)); - - data.assign(data.max_size(), -1); - data.assign(original.begin(), original.end()); - - position = data.insert(data.begin() + 3, 2, 5); - - CHECK_EQUAL(expected2.size(), data.size()); - CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); - CHECK_EQUAL(3, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertNValueExcess) - { - CompareData original = { 1, 2, 3, 4 }; - Data data(original.begin(), original.end()); - - CHECK_THROW(data.insert(data.begin(), 3, 5), etl::deque_full); - CHECK_THROW(data.insert(data.end(), 3, 5), etl::deque_full); - CHECK_THROW(data.insert(data.begin() + 2, 3, 5), etl::deque_full); - } - - //************************************************************************* - TEST(InsertRangeBegin) - { - CompareData original = { 1, 2, 3 }; - CompareData range = { 4, 5 }; - CompareData expected = { 4, 5, 1, 2, 3 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin(), range.begin(), range.end()); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - } - - //************************************************************************* - TEST(InsertRangeEnd) - { - CompareData original = { 1, 2, 3 }; - CompareData range = { 4, 5 }; - CompareData expected = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.end(), range.cbegin(), range.cend()); - - CHECK_EQUAL(expected.size(), data.size()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - } - - //************************************************************************* - TEST(InsertRangeMiddle) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData range = { 5, 6 }; - CompareData expected1 = { 1, 5, 6, 2, 3, 4 }; - CompareData expected2 = { 1, 2, 3, 5, 6, 4 }; - Data data(original.begin(), original.end()); - - Data::iterator position = data.insert(data.begin() + 1, range.begin(), range.end()); - - CHECK_EQUAL(expected1.size(), data.size()); - CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); - CHECK_EQUAL(1, std::distance(data.begin(), position)); - - data.assign(original.begin(), original.end()); - - position = data.insert(data.begin() + 3, range.begin(), range.end()); - - CHECK_EQUAL(expected2.size(), data.size()); - CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); - CHECK_EQUAL(3, std::distance(data.begin(), position)); - } - - //************************************************************************* - TEST(InsertRangeExcess) - { - CompareData original = { 1, 2, 3, 4 }; - CompareData range = { 5, 6, 7 }; - Data data(original.begin(), original.end()); - - CHECK_THROW(data.insert(data.begin(), range.begin(), range.end()), etl::deque_full); - CHECK_THROW(data.insert(data.end(), range.begin(), range.end()), etl::deque_full); - CHECK_THROW(data.insert(data.begin() + 2, range.begin(), range.end()), etl::deque_full); - } - - //************************************************************************* - TEST(EraseBegin) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected = { 2, 3, 4, 5, 6 }; - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - Data::iterator i_next = data.erase(data.begin()); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.begin().get_index()); - } - - //************************************************************************* - TEST(EraseEnd) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - Data::iterator i_erase = data.end() - 1; - Data::iterator i_next = data.erase(i_erase); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.end().get_index()); - } - - //************************************************************************* - TEST(EraseMiddle) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected1 = { 1, 3, 4, 5, 6 }; - CompareData expected2 = { 1, 2, 3, 4, 6 }; - - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - // Erase near beginning. - Data::iterator i_erase = data.begin() + 1; - Data::iterator i_next = data.erase(i_erase); - - CHECK_EQUAL(Data::difference_type(expected1.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.begin().get_index() + 1); - - data.assign(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - // Erase near end. - i_next = data.erase(data.begin() + 4); - - CHECK_EQUAL(Data::difference_type(expected2.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.begin().get_index() + 4); - } - - //************************************************************************* - TEST(EraseRangeBegin) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected = { 3, 4, 5, 6 }; - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - Data::iterator i_next = data.erase(data.begin(), data.begin() + 2); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.begin().get_index()); - } - - //************************************************************************* - TEST(EraseRangeEnd) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected = { 1, 2, 3, 4 }; - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - Data::iterator i_next = data.erase(data.end() - 2, data.end()); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), data.end().get_index()); - } - - //************************************************************************* - TEST(EraseRangeMiddle) - { - CompareData original = { 0, 0, 1, 2, 3, 4 }; - CompareData expected1 = { 1, 4, 5, 6 }; - CompareData expected2 = { 1, 2, 3, 6 }; - - Data data(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - Data::iterator i_next = data.erase(data.begin() + 1, data.begin() + 3); - - CHECK_EQUAL(Data::difference_type(expected1.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected1.begin(), expected1.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), (data.begin() + 1).get_index()); - - data.assign(original.begin(), original.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.push_back(5); - data.push_back(6); - - i_next = data.erase(data.begin() + 3, data.begin() + 5); - - CHECK_EQUAL(Data::difference_type(expected2.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected2.begin(), expected2.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), (data.begin() + 3).get_index()); - - CompareData original2 = { 0, 0, 0, 0, 1, 2}; - CompareData expected3 = { 1, 2, 5, 6 }; - - data.assign(original2.begin(), original2.end()); - - // Cause rollover. - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(3); - data.push_back(4); - data.push_back(5); - data.push_back(6); - - i_next = data.erase(data.begin() + 2, data.begin() + 4); - - CHECK_EQUAL(Data::difference_type(expected3.size()), std::distance(data.begin(), data.end())); - CHECK(std::equal(expected3.begin(), expected3.end(), data.begin())); - CHECK_EQUAL(i_next.get_index(), (data.begin() + 2).get_index()); - } - - //************************************************************************* - TEST(Sort) - { - CompareData original = { 5, 3, 4, 1, 2 }; - CompareData expected = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - std::sort(data.begin(), data.end()); - - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - } - - //************************************************************************* - TEST(ReverseForwardIterators) - { - CompareData original = { 1, 2, 3, 4, 5 }; - CompareData expected = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - std::reverse(data.begin(), data.end()); + Data data1(compare_data1.begin(), compare_data1.end()); + Data data2(compare_data2.begin(), compare_data2.end()); - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - } - - //************************************************************************* - TEST(ReverseReverseIterators) - { - CompareData original = { 1, 2, 3, 4, 5 }; - CompareData expected = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - std::reverse(data.rbegin(), data.rend()); - - CHECK(std::equal(expected.begin(), expected.end(), data.begin())); - } - - //************************************************************************* - TEST(BeginEnd) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::iterator begin = data.begin(); - Data::iterator end = data.end(); - - CHECK_EQUAL(Data::difference_type(original.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, data.begin())); - } - - //************************************************************************* - TEST(BeginEndConst) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::const_iterator begin = data.begin(); - Data::const_iterator end = data.end(); - - CHECK_EQUAL(Data::difference_type(original.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, original.begin())); - } - - //************************************************************************* - TEST(CBeginCEnd) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::const_iterator begin = data.cbegin(); - Data::const_iterator end = data.cend(); - - CHECK_EQUAL(Data::difference_type(original.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, original.begin())); - } - - //************************************************************************* - TEST(RBeginREnd) - { - CompareData original = { 1, 2, 3, 4, 5 }; - CompareData expected = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - Data::reverse_iterator begin = data.rbegin(); - Data::reverse_iterator end = data.rend(); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, expected.begin())); - } - - //************************************************************************* - TEST(RBeginREndConst) - { - CompareData original = { 1, 2, 3, 4, 5 }; - CompareData expected = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - Data::const_reverse_iterator begin = data.rbegin(); - Data::const_reverse_iterator end = data.rend(); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, expected.begin())); - } - - //************************************************************************* - TEST(CRBeginCREnd) - { - CompareData original = { 1, 2, 3, 4, 5 }; - CompareData expected = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - Data::const_reverse_iterator begin = data.crbegin(); - Data::const_reverse_iterator end = data.crend(); - - CHECK_EQUAL(Data::difference_type(expected.size()), std::distance(begin, end)); - CHECK(std::equal(begin, end, expected.begin())); - } - - //************************************************************************* - TEST(Iterators) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::iterator begin = data.begin(); - Data::iterator end = data.begin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(IteratorsRolloverRight) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - // Cause rollover right. - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(6); - data.push_back(7); - data.push_back(8); - - Data::iterator begin = data.begin(); - Data::iterator end = data.begin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(6, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(7, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(5, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(6, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(7, *begin); - CHECK_EQUAL(8, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(8, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(6, *end); - } - - //************************************************************************* - TEST(IteratorsRolloverLeft) - { - CompareData original = { 4, 5, 6, 7, 8 }; - Data data(original.begin(), original.end()); - - // Cause rollover left. - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(3); - data.push_front(2); - data.push_front(1); - - Data::iterator begin = data.begin(); - Data::iterator end = data.begin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ConstIterators) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - Data::const_iterator begin = data.cbegin(); - Data::const_iterator end = data.cbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ConstIteratorsRolloverRight) - { - CompareData original = { 1, 2, 3, 4, 5 }; - Data data(original.begin(), original.end()); - - // Cause rollover right. - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(6); - data.push_back(7); - data.push_back(8); - - Data::const_iterator begin = data.cbegin(); - Data::const_iterator end = data.cbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(6, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(7, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(5, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(6, *begin); - CHECK_EQUAL(8, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(7, *begin); - CHECK_EQUAL(8, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(8, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(6, *end); - } - - //************************************************************************* - TEST(ConstIteratorsRolloverLeft) - { - CompareData original = { 4, 5, 6, 7, 8 }; - Data data(original.begin(), original.end()); - - // Cause rollover left. - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(3); - data.push_front(2); - data.push_front(1); - - Data::const_iterator begin = data.cbegin(); - Data::const_iterator end = data.cbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ReverseIterators) - { - CompareData original = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - Data::reverse_iterator begin = data.rbegin(); - Data::reverse_iterator end = data.rbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ReverseIteratorsRolloverRight) - { - CompareData original = { 0, 0, 0, 5, 4 }; - Data data(original.begin(), original.end()); - - // Cause rollover right. - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(3); - data.push_back(2); - data.push_back(1); - - Data::reverse_iterator begin = data.rbegin(); - Data::reverse_iterator end = data.rbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ReverseIteratorsRolloverLeft) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - // Cause rollover left. - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(3); - data.push_front(4); - data.push_front(5); - - Data::reverse_iterator begin = data.rbegin(); - Data::reverse_iterator end = data.rbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ConstReverseIterators) - { - CompareData original = { 5, 4, 3, 2, 1 }; - Data data(original.begin(), original.end()); - - Data::const_reverse_iterator begin = data.crbegin(); - Data::const_reverse_iterator end = data.crbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ConstReverseIteratorsRolloverRight) - { - CompareData original = { 0, 0, 0, 5, 4 }; - Data data(original.begin(), original.end()); - - // Cause rollover right. - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(3); - data.push_back(2); - data.push_back(1); - - Data::const_reverse_iterator begin = data.crbegin(); - Data::const_reverse_iterator end = data.crbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(ConstReverseIteratorsRolloverLeft) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - // Cause rollover left. - data.pop_back(); - data.push_front(3); - data.pop_back(); - data.push_front(4); - data.pop_back(); - data.push_front(5); - - Data::const_reverse_iterator begin = data.crbegin(); - Data::const_reverse_iterator end = data.crbegin(); - - CHECK_EQUAL(0, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(1, *end); - ++end; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(2, *end); - ++end; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - ++end; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(4, *end); - ++end; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(3, std::distance(begin, end)); - CHECK_EQUAL(2, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(3, *begin); - CHECK_EQUAL(5, *end); - ++begin; - CHECK_EQUAL(1, std::distance(begin, end)); - CHECK_EQUAL(4, *begin); - CHECK_EQUAL(5, *end); - begin -= 3; - CHECK_EQUAL(4, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(5, *end); - end -= 2; - CHECK_EQUAL(2, std::distance(begin, end)); - CHECK_EQUAL(1, *begin); - CHECK_EQUAL(3, *end); - } - - //************************************************************************* - TEST(IteratorsNegativeDistance) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - CHECK_EQUAL(-5, std::distance(data.end(), data.begin())); - } - - //************************************************************************* - TEST(ConstIteratorsNegativeDistance) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - CHECK_EQUAL(-5, std::distance(data.cend(), data.cbegin())); - } - - //************************************************************************* - TEST(ReverseIteratorsNegativeDistance) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - CHECK_EQUAL(-5, std::distance(data.rend(), data.rbegin())); - } - - //************************************************************************* - TEST(ConstReverseIteratorsNegativeDistance) - { - CompareData original = { 2, 1, 0, 0, 0 }; - Data data(original.begin(), original.end()); - - CHECK_EQUAL(-5, std::distance(data.crend(), data.crbegin())); - } - - //************************************************************************* - TEST(IteratorsComparison) - { - Data data(6, 0); - - Data::iterator first = data.begin() + 1; - Data::iterator second = data.begin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(IteratorsComparisonRolloverRight) - { - Data data(6, 0); - - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(1); - data.push_back(1); - data.push_back(1); - - Data::iterator first = data.begin() + 1; - Data::iterator second = data.begin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstIteratorsComparison) - { - Data data(6, 0); - - Data::const_iterator first = data.cbegin() + 1; - Data::const_iterator second = data.cbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstIteratorsComparisonRolloverRight) - { - Data data(6, 0); - - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(1); - data.push_back(1); - data.push_back(1); - - Data::const_iterator first = data.cbegin() + 1; - Data::const_iterator second = data.cbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstIteratorsComparisonRolloverLeft) - { - Data data(6, 0); - - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(1); - data.push_front(1); - data.push_front(1); - - Data::const_iterator first = data.cbegin() + 1; - Data::const_iterator second = data.cbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ReverseIteratorsComparison) - { - Data data(6, 0); - - Data::reverse_iterator first = data.rbegin() + 1; - Data::reverse_iterator second = data.rbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ReverseIteratorsComparisonRolloverRight) - { - Data data(6, 0); - - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(1); - data.push_back(1); - data.push_back(1); - - Data::reverse_iterator first = data.rbegin() + 1; - Data::reverse_iterator second = data.rbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ReverseIteratorsComparisonRolloverLeft) - { - Data data(6, 0); - - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(1); - data.push_front(1); - data.push_front(1); - - Data::reverse_iterator first = data.rbegin() + 1; - Data::reverse_iterator second = data.rbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstReverseIteratorsComparison) - { - Data data(6, 0); - - Data::const_reverse_iterator first = data.crbegin() + 1; - Data::const_reverse_iterator second = data.crbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstReverseIteratorsComparisonRolloverRight) - { - Data data(6, 0); - - data.pop_front(); - data.pop_front(); - data.pop_front(); - data.push_back(1); - data.push_back(1); - data.push_back(1); - - Data::const_reverse_iterator first = data.crbegin() + 1; - Data::const_reverse_iterator second = data.crbegin() + 4; - - CHECK(first < second); - CHECK(!(second < first)); - } - - //************************************************************************* - TEST(ConstReverseIteratorsComparisonRolloverLeft) - { - Data data(6, 0); + swap(data1, data2); - data.pop_back(); - data.pop_back(); - data.pop_back(); - data.push_front(1); - data.push_front(1); - data.push_front(1); + CHECK_EQUAL(compare_data2.size(), data1.size()); + CHECK_EQUAL(compare_data1.size(), data2.size()); - Data::const_reverse_iterator first = data.crbegin() + 1; - Data::const_reverse_iterator second = data.crbegin() + 4; + CHECK_EQUAL(std::distance(compare_data2.begin(), compare_data2.end()), std::distance(data1.begin(), data1.end())); + CHECK_EQUAL(std::distance(compare_data1.begin(), compare_data1.end()), std::distance(data2.begin(), data2.end())); - CHECK(first < second); - CHECK(!(second < first)); + CHECK(std::equal(compare_data2.begin(), compare_data2.end(), data1.begin())); + CHECK(std::equal(compare_data1.begin(), compare_data1.end(), data2.begin())); } //************************************************************************* - TEST(OperatorEqual) + TEST(test_equality_operator) { - CompareData original = { 1, 2, 3, 4, 5, 6 }; - CompareData modified = { 6, 5, 4, 3, 2, 1 }; + Compare_Data same = { 1, 2, 3, 4, 5, 6 }; + Compare_Data different = { 6, 5, 4, 3, 2, 1 }; - Data testDeque1(original.begin(), original.end()); - Data testDeque2(testDeque1); + Data deque1(same.begin(), same.end()); + Data deque2(deque1); - CHECK(testDeque1 == testDeque2); + CHECK(deque1 == deque2); - // Change testDeque2's data. - std::copy(modified.begin(), modified.end(), testDeque2.begin()); + // Change deque2's data. + std::copy(different.begin(), different.end(), deque2.begin()); - CHECK(testDeque1 != testDeque2); + CHECK(!(deque1 == deque2)); } + + //************************************************************************* + TEST(test_inequality_operator) + { + Compare_Data same = { 1, 2, 3, 4, 5, 6 }; + Compare_Data different = { 6, 5, 4, 3, 2, 1 }; + + Data deque1(same.begin(), same.end()); + Data deque2(deque1); + + CHECK(!(deque1 != deque2)); + + // Change deque2's data. + std::copy(different.begin(), different.end(), deque2.begin()); + + CHECK(deque1 != deque2); + } }; } diff --git a/test/test_integral_limits.cpp b/test/test_integral_limits.cpp index 8c5e341f..f7fa3339 100644 --- a/test/test_integral_limits.cpp +++ b/test/test_integral_limits.cpp @@ -28,6 +28,7 @@ SOFTWARE. #include #include +#include #include "../integral_limits.h" @@ -40,66 +41,66 @@ namespace { //************************************************************************* TEST(MinTest) - { - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); - CHECK_EQUAL(std::numeric_limits::min(), etl::integral_limits::min); + { + CHECK_EQUAL(std::numeric_limits::min(), (char)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (signed char)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (unsigned char)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (short)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (unsigned short)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (int)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (unsigned int)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (long)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (unsigned long)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (long long)etl::integral_limits::min); + CHECK_EQUAL(std::numeric_limits::min(), (unsigned long long)etl::integral_limits::min); } //************************************************************************* TEST(MaxTest) { - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); - CHECK_EQUAL(std::numeric_limits::max(), etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (char)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (signed char)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (unsigned char)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (short)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (unsigned short)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (int)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (unsigned int)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (long)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (unsigned long)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (long long)etl::integral_limits::max); + CHECK_EQUAL(std::numeric_limits::max(), (unsigned long long)etl::integral_limits::max); } //************************************************************************* TEST(BitsTest) { - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::type>::digits, etl::integral_limits::bits); - CHECK_EQUAL(std::numeric_limits::digits, etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::type>::digits, (int)etl::integral_limits::bits); + CHECK_EQUAL(std::numeric_limits::digits, (int)etl::integral_limits::bits); } //************************************************************************* TEST(IsSignedTest) { - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); - CHECK_EQUAL(std::numeric_limits::is_signed, etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); + CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); } }; } diff --git a/test/test_largest.cpp b/test/test_largest.cpp index 04b33c83..c07a1bdb 100644 --- a/test/test_largest.cpp +++ b/test/test_largest.cpp @@ -35,26 +35,26 @@ namespace SUITE(TestLargest) { //************************************************************************* - TEST(PODTest) + TEST(test_pod_type) { size_t size; bool type; - size = etl::largest::size; - type = std::is_same::type>::value; + size = etl::largest_type::size; + type = std::is_same::type>::value; CHECK_EQUAL(sizeof(int), size); CHECK(type); - size = etl::largest::size; - type = std::is_same::type>::value; + size = etl::largest_type::size; + type = std::is_same::type>::value; CHECK_EQUAL(sizeof(int), size); CHECK(type); } //************************************************************************* - TEST(NonPODTest) + TEST(test_non_pod_type) { size_t size; bool type; @@ -63,17 +63,37 @@ namespace struct S2 { char a; short b; char c; }; struct S3 { int a; short b; char c; }; - size = etl::largest::size; - type = std::is_same::type>::value; + size = etl::largest_type::size; + type = std::is_same::type>::value; CHECK_EQUAL(sizeof(S3), size); CHECK(type); - size = etl::largest::size; - type = std::is_same::type>::value; + size = etl::largest_type::size; + type = std::is_same::type>::value; CHECK_EQUAL(sizeof(S3), size); CHECK(type); } + + //************************************************************************* + TEST(test_pod_alignment) + { + size_t size = etl::largest_alignment::value; + + CHECK_EQUAL(std::alignment_of::value, size); + } + + //************************************************************************* + TEST(test_non_pod_alignment) + { + struct S1 { char a; char b; char c; }; + struct S2 { char a; short b; char c; }; + struct S3 { int a; short b; char c; }; + + size_t size = etl::largest_alignment::value; + + CHECK_EQUAL(std::alignment_of::value, size); + } }; }