diff --git a/test/test_main.cpp b/test/test_main.cpp new file mode 100644 index 0000000..6a29c5f --- /dev/null +++ b/test/test_main.cpp @@ -0,0 +1,556 @@ +#include +#include +#include + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-W#pragma-messages" +#define UNIT_TEST + +class test_const_vector; + +#include "const_vector.hpp" + +//#define TEST_CONSTEVAL(msg, block...) { static_assert([&]() consteval -> bool { block; return true; }(), msg); } + +#define MACRO_TO_STRING(s) TO_STRING(s) +#define TO_STRING(s) #s +#define C_ARR_LEN(arr) (sizeof(arr)/sizeof(arr[0])) + +#define MSG_ASSERT(assertion...) "Line " MACRO_TO_STRING(__LINE__) ": Assertion " #assertion " failed. " +#define MSG_ASSERT_MSG(MSG, assertion...) "Line " MACRO_TO_STRING(__LINE__) ": Assertion " #assertion " failed. " MSG + +#define ASSERT(assertion) static_assert(assertion, MSG_ASSERT(assertion)); +#define ASSERT_MSG(assertion, MSG) static_assert(assertion, MSG_ASSERT_MSG(MSG, assertion)); +#define ASSERT_ALL_EQ(first, last, eq) static_assert(std::all_of(first, last, [] (const T& e) { constexpr T eqv = eq; if constexpr (std::is_same_v) { return std::string_view(e) == eqv; } else { return e == eqv; } }), MSG_ASSERT(all_of( #first, #last ) == #eq)); +#define ASSERT_ARR_EQ(first, last, eq) static_assert(std::equal(first, last, eq, [] (const T& a, const T& b) { if constexpr (std::is_same_v) { return std::string_view(a) == b; } else { return a == b; } }), MSG_ASSERT(equal ( #first, #last ), #eq)); + +#define ASSERT_ALL_VEC_EQ(vec, eq) ASSERT_ALL_EQ(vec._arr, vec._arr + vec._len, eq) +#define ASSERT_RANGE_VEC_EQ(vec, startI, endI, eq) ASSERT_ALL_EQ((vec._arr + startI), (vec._arr + endI), eq) +#define ASSERT_VEC_ARR_EQ(vec, eq) ASSERT_ARR_EQ(vec._arr, vec._arr + vec._len, eq) +#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_ARR_EQ((vec._arr + startI), (vec._arr + endI), eq) + + +class test_const_vector { + + public: + + struct TestStruct { + int x = 0; + char c = 0; + const char * s = "This is a string"; + + constexpr bool operator==(const TestStruct &other) const { return x == other.x && c == other.c && std::string_view(s) == other.s; } + }; + +#define GEN_TEST_STRUCT_ARR(nr, i) TestStruct(C_VI_TEST_ARR##nr[i], C_VC_TEST_ARR##nr[i], C_VS_TEST_ARR##nr[i]) + + +#define TEST_VEC1_CAPACITY 5 +#define TEST_VEC2_CAPACITY 10 + +#define TEST_VEC1_SIZE 3 +#define TEST_VEC2_SIZE 7 + +#define VI_TEST_VAL 5 +#define VC_TEST_VAL 'T' +#define VS_TEST_VAL "Test string" +#define VO_TEST_VAL TestStruct(VI_TEST_VAL, VC_TEST_VAL, VS_TEST_VAL) + +#define VI_TEST_ARR1 { 1, 2, 3, 4 } +#define VI_TEST_ARR2 { 5, 6, 7, 8, 9, 10, 11, 12 } + static constexpr const int C_VI_TEST_ARR1[] = VI_TEST_ARR1; + static constexpr const int C_VI_TEST_ARR2[] = VI_TEST_ARR2; + static constexpr const std::array STD_VI_TEST_ARR1 = VI_TEST_ARR1; + static constexpr const std::array STD_VI_TEST_ARR2 = VI_TEST_ARR2; + static constexpr const std::size_t VI_TEST_ARR1_LEN = C_ARR_LEN(C_VI_TEST_ARR1); + static constexpr const std::size_t VI_TEST_ARR2_LEN = C_ARR_LEN(C_VI_TEST_ARR2); + +#define VC_TEST_ARR1 { 'a', 'B', 'c', 'D' } +#define VC_TEST_ARR2 { 'e', 'F', 'g', 'H', 'i', 'J', '\n', '\0' } + static constexpr const char C_VC_TEST_ARR1[] = VC_TEST_ARR1; + static constexpr const char C_VC_TEST_ARR2[] = VC_TEST_ARR2; + static constexpr const std::array STD_VC_TEST_ARR1 = VC_TEST_ARR1; + static constexpr const std::array STD_VC_TEST_ARR2 = VC_TEST_ARR2; + static constexpr const std::size_t VC_TEST_ARR1_LEN = C_ARR_LEN(C_VC_TEST_ARR1); + static constexpr const std::size_t VC_TEST_ARR2_LEN = C_ARR_LEN(C_VC_TEST_ARR2); + +#define VS_TEST_ARR1 { "Lorem", "ipsum", "dolor", "sit" } +#define VS_TEST_ARR2 { "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod", "tempor", "\0" } + static constexpr const char * C_VS_TEST_ARR1[] = VS_TEST_ARR1; + static constexpr const char * C_VS_TEST_ARR2[] = VS_TEST_ARR2; + static constexpr const std::array STD_VS_TEST_ARR1 = VS_TEST_ARR1; + static constexpr const std::array STD_VS_TEST_ARR2 = VS_TEST_ARR2; + static constexpr const std::size_t VS_TEST_ARR1_LEN = C_ARR_LEN(C_VS_TEST_ARR1); + static constexpr const std::size_t VS_TEST_ARR2_LEN = C_ARR_LEN(C_VS_TEST_ARR2); + +#define VO_TEST_ARR1 { GEN_TEST_STRUCT_ARR(1, 0), \ + GEN_TEST_STRUCT_ARR(1, 1), \ + GEN_TEST_STRUCT_ARR(1, 2), \ + GEN_TEST_STRUCT_ARR(1, 3) } +#define VO_TEST_ARR2 { GEN_TEST_STRUCT_ARR(2, 0), \ + GEN_TEST_STRUCT_ARR(2, 1), \ + GEN_TEST_STRUCT_ARR(2, 2), \ + GEN_TEST_STRUCT_ARR(2, 3), \ + GEN_TEST_STRUCT_ARR(2, 4), \ + GEN_TEST_STRUCT_ARR(2, 5), \ + GEN_TEST_STRUCT_ARR(2, 6), \ + GEN_TEST_STRUCT_ARR(2, 7) } + static constexpr TestStruct C_VO_TEST_ARR1[] = VO_TEST_ARR1; + static constexpr TestStruct C_VO_TEST_ARR2[] = VO_TEST_ARR2; + static constexpr const std::array STD_VO_TEST_ARR1 = VO_TEST_ARR1; + static constexpr const std::array STD_VO_TEST_ARR2 = VO_TEST_ARR2; + static constexpr const std::size_t VO_TEST_ARR1_LEN = C_ARR_LEN(C_VO_TEST_ARR1); + static constexpr const std::size_t VO_TEST_ARR2_LEN = C_ARR_LEN(C_VO_TEST_ARR2); + + + static consteval bool test_constructor_default() { + +#pragma message("Testing default constructor") + + constexpr cc::const_vector vi1; + constexpr cc::const_vector vi2; + + ASSERT(vi1._len == TEST_VEC1_CAPACITY) + ASSERT(vi2._len == TEST_VEC2_CAPACITY) + ASSERT(vi1._size == 0) + ASSERT(vi2._size == 0) + ASSERT_ALL_VEC_EQ(vi1, int()) + ASSERT_ALL_VEC_EQ(vi2, int()) + + + constexpr cc::const_vector vc1; + constexpr cc::const_vector vc2; + + ASSERT(vc1._len == TEST_VEC1_CAPACITY) + ASSERT(vc2._len == TEST_VEC2_CAPACITY) + ASSERT(vc1._size == 0) + ASSERT(vc2._size == 0) + ASSERT_ALL_VEC_EQ(vc1, char()) + ASSERT_ALL_VEC_EQ(vc2, char()) + + + constexpr cc::const_vector vs1; + constexpr cc::const_vector vs2; + + ASSERT(vs1._len == TEST_VEC1_CAPACITY) + ASSERT(vs2._len == TEST_VEC2_CAPACITY) + ASSERT(vs1._size == 0) + ASSERT(vs2._size == 0) + + + constexpr cc::const_vector vo1; + constexpr cc::const_vector vo2; + + ASSERT(vo1._len == TEST_VEC1_CAPACITY) + ASSERT(vo2._len == TEST_VEC2_CAPACITY) + ASSERT(vo1._size == 0) + ASSERT(vo2._size == 0) + ASSERT_ALL_VEC_EQ(vo1, TestStruct{}) + ASSERT_ALL_VEC_EQ(vo2, TestStruct{}) + + + return true; + } + + static consteval bool test_constructor_value() { + +#pragma message("Testing constructor 'const_vector(T &value)'") + + + constexpr cc::const_vector vi1(VI_TEST_VAL); + constexpr cc::const_vector vi2(VI_TEST_VAL); + + ASSERT(vi1._len == TEST_VEC1_CAPACITY) + ASSERT(vi2._len == TEST_VEC2_CAPACITY) + ASSERT(vi1._size == TEST_VEC1_CAPACITY) + ASSERT(vi2._size == TEST_VEC2_CAPACITY) + ASSERT_ALL_VEC_EQ(vi1, VI_TEST_VAL) + ASSERT_ALL_VEC_EQ(vi2, VI_TEST_VAL) + + + constexpr cc::const_vector vc1(VC_TEST_VAL); + constexpr cc::const_vector vc2(VC_TEST_VAL); + + ASSERT(vc1._len == TEST_VEC1_CAPACITY) + ASSERT(vc2._len == TEST_VEC2_CAPACITY) + ASSERT(vc1._size == TEST_VEC1_CAPACITY) + ASSERT(vc2._size == TEST_VEC2_CAPACITY) + ASSERT_ALL_VEC_EQ(vc1, VC_TEST_VAL) + ASSERT_ALL_VEC_EQ(vc2, VC_TEST_VAL) + + + constexpr cc::const_vector vs1(VS_TEST_VAL); + constexpr cc::const_vector vs2(VS_TEST_VAL); + + ASSERT(vs1._len == TEST_VEC1_CAPACITY) + ASSERT(vs2._len == TEST_VEC2_CAPACITY) + ASSERT(vs1._size == TEST_VEC1_CAPACITY) + ASSERT(vs2._size == TEST_VEC2_CAPACITY) + ASSERT_ALL_VEC_EQ(vs1, VS_TEST_VAL) + ASSERT_ALL_VEC_EQ(vs2, VS_TEST_VAL) + + + constexpr cc::const_vector vo1(VO_TEST_VAL); + constexpr cc::const_vector vo2(VO_TEST_VAL); + + ASSERT(vo1._len == TEST_VEC1_CAPACITY) + ASSERT(vo2._len == TEST_VEC2_CAPACITY) + ASSERT(vo1._size == TEST_VEC1_CAPACITY) + ASSERT(vo2._size == TEST_VEC2_CAPACITY) + ASSERT_ALL_VEC_EQ(vo1, VO_TEST_VAL) + ASSERT_ALL_VEC_EQ(vo2, VO_TEST_VAL) + + + return true; + } + + static consteval bool test_constructor_value_size() { + +#pragma message("Testing constructor 'const_vector(size_type size, T &value)'") + + + constexpr cc::const_vector vi1(TEST_VEC1_SIZE, VI_TEST_VAL); + constexpr cc::const_vector vi2(TEST_VEC2_SIZE, VI_TEST_VAL); + + ASSERT(vi1._len == TEST_VEC1_CAPACITY) + ASSERT(vi2._len == TEST_VEC2_CAPACITY) + ASSERT(vi1._size == TEST_VEC1_SIZE) + ASSERT(vi2._size == TEST_VEC2_SIZE) + ASSERT_RANGE_VEC_EQ(vi1, 0, TEST_VEC1_SIZE, VI_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vi1, TEST_VEC1_SIZE, TEST_VEC1_CAPACITY, int()) + ASSERT_RANGE_VEC_EQ(vi2, 0, TEST_VEC2_SIZE, VI_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vi2, TEST_VEC2_SIZE, TEST_VEC2_CAPACITY, int()) + + + constexpr cc::const_vector vc1(TEST_VEC1_SIZE, VC_TEST_VAL); + constexpr cc::const_vector vc2(TEST_VEC2_SIZE, VC_TEST_VAL); + + ASSERT(vc1._len == TEST_VEC1_CAPACITY) + ASSERT(vc2._len == TEST_VEC2_CAPACITY) + ASSERT(vc1._size == TEST_VEC1_SIZE) + ASSERT(vc2._size == TEST_VEC2_SIZE) + ASSERT_RANGE_VEC_EQ(vc1, 0, TEST_VEC1_SIZE, VC_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vc1, TEST_VEC1_SIZE, TEST_VEC1_CAPACITY, char()) + ASSERT_RANGE_VEC_EQ(vc2, 0, TEST_VEC2_SIZE, VC_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vc2, TEST_VEC2_SIZE, TEST_VEC2_CAPACITY, char()) + + + constexpr cc::const_vector vs1(TEST_VEC1_SIZE, VS_TEST_VAL); + constexpr cc::const_vector vs2(TEST_VEC2_SIZE, VS_TEST_VAL); + + ASSERT(vs1._len == TEST_VEC1_CAPACITY) + ASSERT(vs2._len == TEST_VEC2_CAPACITY) + ASSERT(vs1._size == TEST_VEC1_SIZE) + ASSERT(vs2._size == TEST_VEC2_SIZE) + ASSERT_RANGE_VEC_EQ(vs1, 0, TEST_VEC1_SIZE, VS_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vs2, 0, TEST_VEC2_SIZE, VS_TEST_VAL) + + + constexpr cc::const_vector vo1(TEST_VEC1_SIZE, VO_TEST_VAL); + constexpr cc::const_vector vo2(TEST_VEC2_SIZE, VO_TEST_VAL); + + ASSERT(vo1._len == TEST_VEC1_CAPACITY) + ASSERT(vo2._len == TEST_VEC2_CAPACITY) + ASSERT(vo1._size == TEST_VEC1_SIZE) + ASSERT(vo2._size == TEST_VEC2_SIZE) + ASSERT_RANGE_VEC_EQ(vo1, 0, TEST_VEC1_SIZE, VO_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vo1, TEST_VEC1_SIZE, TEST_VEC1_CAPACITY, TestStruct {}) + ASSERT_RANGE_VEC_EQ(vo2, 0, TEST_VEC2_SIZE, VO_TEST_VAL) + ASSERT_RANGE_VEC_EQ(vo2, TEST_VEC2_SIZE, TEST_VEC2_CAPACITY, TestStruct {}) + + + return true; + } + + static consteval bool test_constructor_array() { + +#pragma message("Testing constructor 'const_vector(const value_type (&array)[N])'") + + constexpr cc::const_vector vi1(C_VI_TEST_ARR1); + constexpr cc::const_vector vi2(C_VI_TEST_ARR2); + /*constexpr cc::const_vector vi3(C_VI_TEST_ARR1); + constexpr cc::const_vector vi4(C_VI_TEST_ARR2);*/ + + ASSERT(vi1._len == VI_TEST_ARR1_LEN) + ASSERT(vi2._len == VI_TEST_ARR2_LEN) + ASSERT(vi1._size == VI_TEST_ARR1_LEN) + ASSERT(vi2._size == VI_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vi1, C_VI_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vi2, C_VI_TEST_ARR2) + /*ASSERT(vi3._len == TEST_VEC1_CAPACITY) + ASSERT(vi4._len == TEST_VEC2_CAPACITY) + ASSERT(vi3._size == VI_TEST_ARR1_LEN) + ASSERT(vi4._size == VI_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, VI_TEST_ARR1_LEN, C_VI_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vi3, VI_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, int()) + ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, VI_TEST_ARR2_LEN, C_VI_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vi4, VI_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, int())*/ + + + constexpr cc::const_vector vc1(C_VC_TEST_ARR1); + constexpr cc::const_vector vc2(C_VC_TEST_ARR2); + /*constexpr cc::const_vector vc3(C_VC_TEST_ARR1); + constexpr cc::const_vector vc4(C_VC_TEST_ARR2);*/ + + ASSERT(vc1._len == VC_TEST_ARR1_LEN) + ASSERT(vc2._len == VC_TEST_ARR2_LEN) + ASSERT(vc1._size == VC_TEST_ARR1_LEN) + ASSERT(vc2._size == VC_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vc1, C_VC_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vc2, C_VC_TEST_ARR2) + /*ASSERT(vc3._len == TEST_VEC1_CAPACITY) + ASSERT(vc4._len == TEST_VEC2_CAPACITY) + ASSERT(vc3._size == VC_TEST_ARR1_LEN) + ASSERT(vc4._size == VC_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, VC_TEST_ARR1_LEN, C_VC_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vc3, VC_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, char()) + ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, VC_TEST_ARR2_LEN, C_VC_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vc4, VC_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, char())*/ + + + constexpr cc::const_vector vs1(C_VS_TEST_ARR1); + constexpr cc::const_vector vs2(C_VS_TEST_ARR2); + /*constexpr cc::const_vector vs3(C_VS_TEST_ARR1); + constexpr cc::const_vector vs4(C_VS_TEST_ARR2);*/ + + ASSERT(vs1._len == VS_TEST_ARR1_LEN) + ASSERT(vs2._len == VS_TEST_ARR2_LEN) + ASSERT(vs1._size == VS_TEST_ARR1_LEN) + ASSERT(vs2._size == VS_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vs1, C_VS_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vs2, C_VS_TEST_ARR2) + /*ASSERT(vs3._len == TEST_VEC1_CAPACITY) + ASSERT(vs4._len == TEST_VEC2_CAPACITY) + ASSERT(vs3._size == VS_TEST_ARR1_LEN) + ASSERT(vs4._size == VS_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, VS_TEST_ARR1_LEN, C_VS_TEST_ARR1) + ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, VS_TEST_ARR2_LEN, C_VS_TEST_ARR2)*/ + + + constexpr cc::const_vector vo1(C_VO_TEST_ARR1); + constexpr cc::const_vector vo2(C_VO_TEST_ARR2); + /*constexpr cc::const_vector vo3(C_VO_TEST_ARR1); + constexpr cc::const_vector vo4(C_VO_TEST_ARR2);*/ + + ASSERT(vo1._len == VO_TEST_ARR1_LEN) + ASSERT(vo2._len == VO_TEST_ARR2_LEN) + ASSERT(vo1._size == VO_TEST_ARR1_LEN) + ASSERT(vo2._size == VO_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vo1, C_VO_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vo2, C_VO_TEST_ARR2) + /*ASSERT(vo3._len == TEST_VEC1_CAPACITY) + ASSERT(vo4._len == TEST_VEC2_CAPACITY) + ASSERT(vo3._size == VO_TEST_ARR1_LEN) + ASSERT(vo4._size == VO_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, VO_TEST_ARR1_LEN, C_VO_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vo3, VO_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, TestStruct {}) + ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, VO_TEST_ARR2_LEN, C_VO_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vo4, VO_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, TestStruct {})*/ + + + return true; + } + + static consteval bool test_constructor_initializer_list() { + +#pragma message("Testing constructor 'const_vector(std::initializer_list list)'") + + constexpr cc::const_vector vi1(VI_TEST_ARR1); + constexpr cc::const_vector vi2(VI_TEST_ARR2); + constexpr cc::const_vector vi3(VI_TEST_ARR1); + constexpr cc::const_vector vi4(VI_TEST_ARR2); + + ASSERT(vi1._len == VI_TEST_ARR1_LEN) + ASSERT(vi2._len == VI_TEST_ARR2_LEN) + ASSERT(vi1._size == VI_TEST_ARR1_LEN) + ASSERT(vi2._size == VI_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vi1, C_VI_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vi2, C_VI_TEST_ARR2) + ASSERT(vi3._len == TEST_VEC1_CAPACITY) + ASSERT(vi4._len == TEST_VEC2_CAPACITY) + ASSERT(vi3._size == VI_TEST_ARR1_LEN) + ASSERT(vi4._size == VI_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, VI_TEST_ARR1_LEN, C_VI_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vi3, VI_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, int()) + ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, VI_TEST_ARR2_LEN, C_VI_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vi4, VI_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, int()) + + + constexpr cc::const_vector vc1(VC_TEST_ARR1); + constexpr cc::const_vector vc2(VC_TEST_ARR2); + constexpr cc::const_vector vc3(VC_TEST_ARR1); + constexpr cc::const_vector vc4(VC_TEST_ARR2); + + ASSERT(vc1._len == VC_TEST_ARR1_LEN) + ASSERT(vc2._len == VC_TEST_ARR2_LEN) + ASSERT(vc1._size == VC_TEST_ARR1_LEN) + ASSERT(vc2._size == VC_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vc1, C_VC_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vc2, C_VC_TEST_ARR2) + ASSERT(vc3._len == TEST_VEC1_CAPACITY) + ASSERT(vc4._len == TEST_VEC2_CAPACITY) + ASSERT(vc3._size == VC_TEST_ARR1_LEN) + ASSERT(vc4._size == VC_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, VC_TEST_ARR1_LEN, C_VC_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vc3, VC_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, char()) + ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, VC_TEST_ARR2_LEN, C_VC_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vc4, VC_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, char()) + + + constexpr cc::const_vector vs1(VS_TEST_ARR1); + constexpr cc::const_vector vs2(VS_TEST_ARR2); + constexpr cc::const_vector vs3(VS_TEST_ARR1); + constexpr cc::const_vector vs4(VS_TEST_ARR2); + + ASSERT(vs1._len == VS_TEST_ARR1_LEN) + ASSERT(vs2._len == VS_TEST_ARR2_LEN) + ASSERT(vs1._size == VS_TEST_ARR1_LEN) + ASSERT(vs2._size == VS_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vs1, C_VS_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vs2, C_VS_TEST_ARR2) + ASSERT(vs3._len == TEST_VEC1_CAPACITY) + ASSERT(vs4._len == TEST_VEC2_CAPACITY) + ASSERT(vs3._size == VS_TEST_ARR1_LEN) + ASSERT(vs4._size == VS_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, VS_TEST_ARR1_LEN, C_VS_TEST_ARR1) + ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, VS_TEST_ARR2_LEN, C_VS_TEST_ARR2) + + + constexpr cc::const_vector vo1(VO_TEST_ARR1); + constexpr cc::const_vector vo2(VO_TEST_ARR2); + constexpr cc::const_vector vo3(VO_TEST_ARR1); + constexpr cc::const_vector vo4(VO_TEST_ARR2); + + ASSERT(vo1._len == VO_TEST_ARR1_LEN) + ASSERT(vo2._len == VO_TEST_ARR2_LEN) + ASSERT(vo1._size == VO_TEST_ARR1_LEN) + ASSERT(vo2._size == VO_TEST_ARR2_LEN) + ASSERT_VEC_ARR_EQ(vo1, C_VO_TEST_ARR1) + ASSERT_VEC_ARR_EQ(vo2, C_VO_TEST_ARR2) + ASSERT(vo3._len == TEST_VEC1_CAPACITY) + ASSERT(vo4._len == TEST_VEC2_CAPACITY) + ASSERT(vo3._size == VO_TEST_ARR1_LEN) + ASSERT(vo4._size == VO_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, VO_TEST_ARR1_LEN, C_VO_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vo3, VO_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, TestStruct {}) + ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, VO_TEST_ARR2_LEN, C_VO_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vo4, VO_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, TestStruct {}) + + + return true; + } + + + static consteval bool test_constructor_iterator() { + +#pragma message("Testing constructor 'const_vector(const_vector(InputIt first, InputIt last)'") + + constexpr cc::const_vector vi1(std::begin(C_VI_TEST_ARR1), std::end(C_VI_TEST_ARR1)); + constexpr cc::const_vector vi2(std::begin(C_VI_TEST_ARR2), std::end(C_VI_TEST_ARR2)); + constexpr cc::const_vector vi3(STD_VI_TEST_ARR1.begin(), STD_VI_TEST_ARR1.end()); + constexpr cc::const_vector vi4(STD_VI_TEST_ARR2.begin(), STD_VI_TEST_ARR2.end()); + + ASSERT(vi1._len == TEST_VEC1_CAPACITY) + ASSERT(vi2._len == TEST_VEC2_CAPACITY) + ASSERT(vi1._size == VI_TEST_ARR1_LEN) + ASSERT(vi2._size == VI_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vi1, 0, VI_TEST_ARR1_LEN, C_VI_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vi1, VI_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, int()) + ASSERT_RANGE_VEC_ARR_EQ(vi2, 0, VI_TEST_ARR2_LEN, C_VI_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vi2, VI_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, int()) + ASSERT(vi3._len == TEST_VEC1_CAPACITY) + ASSERT(vi4._len == TEST_VEC2_CAPACITY) + ASSERT(vi3._size == VI_TEST_ARR1_LEN) + ASSERT(vi4._size == VI_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, VI_TEST_ARR1_LEN, C_VI_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vi3, VI_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, int()) + ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, VI_TEST_ARR2_LEN, C_VI_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vi4, VI_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, int()) + + + constexpr cc::const_vector vc1(std::begin(C_VC_TEST_ARR1), std::end(C_VC_TEST_ARR1)); + constexpr cc::const_vector vc2(std::begin(C_VC_TEST_ARR2), std::end(C_VC_TEST_ARR2)); + constexpr cc::const_vector vc3(STD_VC_TEST_ARR1.begin(), STD_VC_TEST_ARR1.end()); + constexpr cc::const_vector vc4(STD_VC_TEST_ARR2.begin(), STD_VC_TEST_ARR2.end()); + + ASSERT(vc1._len == TEST_VEC1_CAPACITY) + ASSERT(vc2._len == TEST_VEC2_CAPACITY) + ASSERT(vc1._size == VC_TEST_ARR1_LEN) + ASSERT(vc2._size == VC_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vc1, 0, VC_TEST_ARR1_LEN, C_VC_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vc1, VC_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, char()) + ASSERT_RANGE_VEC_ARR_EQ(vc2, 0, VC_TEST_ARR2_LEN, C_VC_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vc2, VC_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, char()) + ASSERT(vc3._len == TEST_VEC1_CAPACITY) + ASSERT(vc4._len == TEST_VEC2_CAPACITY) + ASSERT(vc3._size == VC_TEST_ARR1_LEN) + ASSERT(vc4._size == VC_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, VC_TEST_ARR1_LEN, C_VC_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vc3, VC_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, char()) + ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, VC_TEST_ARR2_LEN, C_VC_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vc4, VC_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, char()) + + + constexpr cc::const_vector vs1(std::begin(C_VS_TEST_ARR1), std::end(C_VS_TEST_ARR1)); + constexpr cc::const_vector vs2(std::begin(C_VS_TEST_ARR2), std::end(C_VS_TEST_ARR2)); + constexpr cc::const_vector vs3(STD_VS_TEST_ARR1.begin(), STD_VS_TEST_ARR1.end()); + constexpr cc::const_vector vs4(STD_VS_TEST_ARR2.begin(), STD_VS_TEST_ARR2.end()); + + ASSERT(vs1._len == TEST_VEC1_CAPACITY) + ASSERT(vs2._len == TEST_VEC2_CAPACITY) + ASSERT(vs1._size == VS_TEST_ARR1_LEN) + ASSERT(vs2._size == VS_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vs1, 0, VS_TEST_ARR1_LEN, C_VS_TEST_ARR1) + ASSERT_RANGE_VEC_ARR_EQ(vs2, 0, VS_TEST_ARR2_LEN, C_VS_TEST_ARR2) + ASSERT(vs3._len == TEST_VEC1_CAPACITY) + ASSERT(vs4._len == TEST_VEC2_CAPACITY) + ASSERT(vs3._size == VS_TEST_ARR1_LEN) + ASSERT(vs4._size == VS_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, VS_TEST_ARR1_LEN, C_VS_TEST_ARR1) + ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, VS_TEST_ARR2_LEN, C_VS_TEST_ARR2) + + + constexpr cc::const_vector vo1(std::begin(C_VO_TEST_ARR1), std::end(C_VO_TEST_ARR1)); + constexpr cc::const_vector vo2(std::begin(C_VO_TEST_ARR2), std::end(C_VO_TEST_ARR2)); + constexpr cc::const_vector vo3(STD_VO_TEST_ARR1.begin(), STD_VO_TEST_ARR1.end()); + constexpr cc::const_vector vo4(STD_VO_TEST_ARR2.begin(), STD_VO_TEST_ARR2.end()); + + ASSERT(vo1._len == TEST_VEC1_CAPACITY) + ASSERT(vo2._len == TEST_VEC2_CAPACITY) + ASSERT(vo1._size == VO_TEST_ARR1_LEN) + ASSERT(vo2._size == VO_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vo1, 0, VO_TEST_ARR1_LEN, C_VO_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vo1, VO_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, TestStruct {}) + ASSERT_RANGE_VEC_ARR_EQ(vo2, 0, VO_TEST_ARR2_LEN, C_VO_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vo2, VO_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, TestStruct {}) + ASSERT(vo3._len == TEST_VEC1_CAPACITY) + ASSERT(vo4._len == TEST_VEC2_CAPACITY) + ASSERT(vo3._size == VO_TEST_ARR1_LEN) + ASSERT(vo4._size == VO_TEST_ARR2_LEN) + ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, VO_TEST_ARR1_LEN, C_VO_TEST_ARR1) + ASSERT_RANGE_VEC_EQ(vo3, VO_TEST_ARR1_LEN, TEST_VEC1_CAPACITY, TestStruct {}) + ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, VO_TEST_ARR2_LEN, C_VO_TEST_ARR2) + ASSERT_RANGE_VEC_EQ(vo4, VO_TEST_ARR2_LEN, TEST_VEC2_CAPACITY, TestStruct {}) + + + return true; + } + +}; + +int main(int, char *[]) +{ + std::cout << std::boolalpha; + + std::cout << "Test of default constructor: " << test_const_vector::test_constructor_default() << std::endl; + std::cout << "Test of constructor 'const_vector(T &value)': " << test_const_vector::test_constructor_value() << std::endl; + std::cout << "Test of constructor 'const_vector(const_vector(size_type size, const value_type &value)': " << test_const_vector::test_constructor_value_size() << std::endl; + std::cout << "Test of constructor 'const_vector(const value_type (&array)[N])': " << test_const_vector::test_constructor_array() << std::endl; + std::cout << "Test of constructor 'const_vector(std::initializer_list values)': " << test_const_vector::test_constructor_initializer_list() << std::endl; + std::cout << "Test of constructor 'const_vector(InputIt first, InputIt last)': " << test_const_vector::test_constructor_iterator() << std::endl; + + + return 0; +} + +#pragma clang diagnostic pop \ No newline at end of file