From 468b9a49fc804e0f7a6b041ee6798e42618cc4ae Mon Sep 17 00:00:00 2001 From: Patrick Date: Mon, 29 Jul 2024 18:36:50 +0200 Subject: [PATCH] removed test_main (earlier test of const_vector) --- test/test_main.cpp | 1165 -------------------------------------------- 1 file changed, 1165 deletions(-) delete mode 100644 test/test_main.cpp diff --git a/test/test_main.cpp b/test/test_main.cpp deleted file mode 100644 index 6630ff8..0000000 --- a/test/test_main.cpp +++ /dev/null @@ -1,1165 +0,0 @@ -#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._size, eq) -#define ASSERT_VEC_EQ(vec1, vec2) ASSERT_ARR_EQ(vec1._arr, vec1._arr + vec1._size, vec2._arr) -#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_ARR_EQ((vec._arr + startI), (vec._arr + endI), eq) - - -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; } -}; - - -struct test_defs { - -#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 } - -#define VC_TEST_ARR1 { 'a', 'B', 'c', 'D' } -#define VC_TEST_ARR2 { 'e', 'F', 'g', 'H', 'i', 'J', '\n', '\0' } - -#define VS_TEST_ARR1 { "Lorem", "ipsum", "dolor", "sit" } -#define VS_TEST_ARR2 { "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod", "tempor", "\0" } - -#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 std::initializer_list VI_I_LIST1 = VI_TEST_ARR1; - static constexpr std::initializer_list VI_I_LIST2 = VI_TEST_ARR2; - 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); - static constexpr std::initializer_list VC_I_LIST1 = VC_TEST_ARR1; - static constexpr std::initializer_list VC_I_LIST2 = VC_TEST_ARR2; - 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); - static constexpr std::initializer_list VS_I_LIST1 = VS_TEST_ARR1; - static constexpr std::initializer_list VS_I_LIST2 = VS_TEST_ARR2; - 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); - 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 constexpr std::initializer_list VO_I_LIST1 = VO_TEST_ARR1; - static constexpr std::initializer_list VO_I_LIST2 = VO_TEST_ARR2; - - template - struct get { - template - static consteval auto& i_list(); - - template - static consteval auto & arr(); - - template - static consteval std::size_t arr_len(); - - template - static consteval std::size_t capacity(); - - }; - -}; - -template -template -consteval auto & test_defs::get::i_list() { return nullptr; } -template -template -consteval auto & test_defs::get::arr() { return nullptr; } -template -template -consteval std::size_t test_defs::get::arr_len() { return 0; } -template -template -consteval std::size_t test_defs::get::capacity() { return 0; } - - -template<> template<> consteval auto & test_defs::get::i_list<1>() { return VI_I_LIST1; } -template<> template<> consteval auto & test_defs::get::i_list<2>() { return VI_I_LIST2; } -template<> template<> consteval auto & test_defs::get::i_list<1>() { return VC_I_LIST1; } -template<> template<> consteval auto & test_defs::get::i_list<2>() { return VC_I_LIST2; } -template<> template<> consteval auto & test_defs::get::i_list<1>() { return VS_I_LIST1; } -template<> template<> consteval auto & test_defs::get::i_list<2>() { return VS_I_LIST2; } -template<> template<> consteval auto & test_defs::get::i_list<1>() { return VO_I_LIST1; } -template<> template<> consteval auto & test_defs::get::i_list<2>() { return VO_I_LIST2; } - -template<> template<> consteval auto & test_defs::get::arr<1>() { return C_VI_TEST_ARR1; } -template<> template<> consteval auto & test_defs::get::arr<2>() { return C_VI_TEST_ARR2; } -template<> template<> consteval auto & test_defs::get::arr<1>() { return C_VC_TEST_ARR1; } -template<> template<> consteval auto & test_defs::get::arr<2>() { return C_VC_TEST_ARR2; } -template<> template<> consteval auto & test_defs::get::arr<1>() { return C_VS_TEST_ARR1; } -template<> template<> consteval auto & test_defs::get::arr<2>() { return C_VS_TEST_ARR2; } -template<> template<> consteval auto & test_defs::get::arr<1>() { return C_VO_TEST_ARR1; } -template<> template<> consteval auto & test_defs::get::arr<2>() { return C_VO_TEST_ARR2; } - -template<> template<> consteval std::size_t test_defs::get::arr_len<1>() { return VI_TEST_ARR1_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<2>() { return VI_TEST_ARR2_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<1>() { return VC_TEST_ARR1_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<2>() { return VC_TEST_ARR2_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<1>() { return VS_TEST_ARR1_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<2>() { return VS_TEST_ARR2_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<1>() { return VO_TEST_ARR1_LEN; } -template<> template<> consteval std::size_t test_defs::get::arr_len<2>() { return VO_TEST_ARR2_LEN; } - -template<> template<> consteval std::size_t test_defs::get::capacity<1>() { return TEST_VEC1_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<2>() { return TEST_VEC2_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<1>() { return TEST_VEC1_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<2>() { return TEST_VEC2_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<1>() { return TEST_VEC1_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<2>() { return TEST_VEC2_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<1>() { return TEST_VEC1_CAPACITY; } -template<> template<> consteval std::size_t test_defs::get::capacity<2>() { return TEST_VEC2_CAPACITY; } - - - -class test_const_vector : public test_defs { - - public: - - 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; - } - - static consteval bool test_constructor_copy() { - -#pragma message("Testing copy constructors") - - constexpr cc::const_vector vi1(C_VI_TEST_ARR1); - constexpr cc::const_vector vi2(C_VI_TEST_ARR2); - constexpr cc::const_vector vi1c(vi1); - constexpr cc::const_vector vi2c(vi2); - constexpr cc::const_vector vi3(vi1); - constexpr cc::const_vector vi4(vi2); - - ASSERT(vi1c._len == vi1._len) - ASSERT(vi2c._len == vi2._len) - ASSERT(vi1c._size == vi1._size) - ASSERT(vi2c._size == vi2._size) - ASSERT_VEC_EQ(vi1c, vi1) - ASSERT_VEC_EQ(vi2c, vi2) - ASSERT(vi3._len == TEST_VEC1_CAPACITY) - ASSERT(vi4._len == TEST_VEC2_CAPACITY) - ASSERT(vi3._size == vi1._size) - ASSERT(vi4._size == vi2._size) - ASSERT_VEC_EQ(vi3, vi1) - ASSERT_VEC_EQ(vi4, vi2) - - - constexpr cc::const_vector vc1(C_VC_TEST_ARR1); - constexpr cc::const_vector vc2(C_VC_TEST_ARR2); - constexpr cc::const_vector vc1c(vc1); - constexpr cc::const_vector vc2c(vc2); - constexpr cc::const_vector vc3(vc1); - constexpr cc::const_vector vc4(vc2); - - ASSERT(vc1c._len == vc1._len) - ASSERT(vc2c._len == vc2._len) - ASSERT(vc1c._size == vc1._size) - ASSERT(vc2c._size == vc2._size) - ASSERT_VEC_EQ(vc1c, vc1) - ASSERT_VEC_EQ(vc2c, vc2) - ASSERT(vc3._len == TEST_VEC1_CAPACITY) - ASSERT(vc4._len == TEST_VEC2_CAPACITY) - ASSERT(vc3._size == vc1._size) - ASSERT(vc4._size == vc2._size) - ASSERT_VEC_EQ(vc3, vc1) - ASSERT_VEC_EQ(vc4, vc2) - - - constexpr cc::const_vector vs1(C_VS_TEST_ARR1); - constexpr cc::const_vector vs2(C_VS_TEST_ARR2); - constexpr cc::const_vector vs1c(vs1); - constexpr cc::const_vector vs2c(vs2); - constexpr cc::const_vector vs3(vs1); - constexpr cc::const_vector vs4(vs2); - - ASSERT(vs1c._len == vs1._len) - ASSERT(vs2c._len == vs2._len) - ASSERT(vs1c._size == vs1._size) - ASSERT(vs2c._size == vs2._size) - ASSERT_VEC_EQ(vs1c, vs1) - ASSERT_VEC_EQ(vs2c, vs2) - ASSERT(vs3._len == TEST_VEC1_CAPACITY) - ASSERT(vs4._len == TEST_VEC2_CAPACITY) - ASSERT(vs3._size == vs1._size) - ASSERT(vs4._size == vs2._size) - ASSERT_VEC_EQ(vs3, vs1) - ASSERT_VEC_EQ(vs4, vs2) - - - constexpr cc::const_vector vo1(C_VO_TEST_ARR1); - constexpr cc::const_vector vo2(C_VO_TEST_ARR2); - constexpr cc::const_vector vo1c(vo1); - constexpr cc::const_vector vo2c(vo2); - constexpr cc::const_vector vo3(vo1); - constexpr cc::const_vector vo4(vo2); - - ASSERT(vo1c._len == vo1._len) - ASSERT(vo2c._len == vo2._len) - ASSERT(vo1c._size == vo1._size) - ASSERT(vo2c._size == vo2._size) - ASSERT_VEC_EQ(vo1c, vo1) - ASSERT_VEC_EQ(vo2c, vo2) - ASSERT(vo3._len == TEST_VEC1_CAPACITY) - ASSERT(vo4._len == TEST_VEC2_CAPACITY) - ASSERT(vo3._size == vo1._size) - ASSERT(vo4._size == vo2._size) - ASSERT_VEC_EQ(vo3, vo1) - ASSERT_VEC_EQ(vo4, vo2) - - - return true; - } - - static consteval bool test_constructor_move() { - -#pragma message("Testing move constructor") - - constexpr cc::const_vector vi1(C_VI_TEST_ARR1); - constexpr cc::const_vector vi2(C_VI_TEST_ARR2); - constexpr cc::const_vector vi1c(vi1); - constexpr cc::const_vector vi2c(vi2); - constexpr cc::const_vector vi3(const_cast&&>(vi1)); - constexpr cc::const_vector vi4(const_cast&&>(vi2)); - - ASSERT(vi3._len == vi1c._len) - ASSERT(vi4._len == vi2c._len) - ASSERT(vi3._size == vi1c._size) - ASSERT(vi4._size == vi2c._size) - ASSERT_VEC_EQ(vi3, vi1c) - ASSERT_VEC_EQ(vi4, vi2c) - - - constexpr cc::const_vector vc1(C_VC_TEST_ARR1); - constexpr cc::const_vector vc2(C_VC_TEST_ARR2); - constexpr cc::const_vector vc1c(vc1); - constexpr cc::const_vector vc2c(vc2); - constexpr cc::const_vector vc3(const_cast&&>(vc1)); - constexpr cc::const_vector vc4(const_cast&&>(vc2)); - - ASSERT(vi3._len == vi1c._len) - ASSERT(vi4._len == vi2c._len) - ASSERT(vi3._size == vi1c._size) - ASSERT(vi4._size == vi2c._size) - ASSERT_VEC_EQ(vi3, vi1c) - ASSERT_VEC_EQ(vi4, vi2c) - - - constexpr cc::const_vector vs1(C_VS_TEST_ARR1); - constexpr cc::const_vector vs2(C_VS_TEST_ARR2); - constexpr cc::const_vector vs1c(vs1); - constexpr cc::const_vector vs2c(vs2); - constexpr cc::const_vector vs3(const_cast&&>(vs1)); - constexpr cc::const_vector vs4(const_cast&&>(vs2)); - - ASSERT(vs3._len == vs1c._len) - ASSERT(vs4._len == vs2c._len) - ASSERT(vs3._size == vs1c._size) - ASSERT(vs4._size == vs2c._size) - ASSERT_VEC_EQ(vs3, vs1c) - ASSERT_VEC_EQ(vs4, vs2c) - - - constexpr cc::const_vector vo1(C_VO_TEST_ARR1); - constexpr cc::const_vector vo2(C_VO_TEST_ARR2); - constexpr cc::const_vector vo1c(vo1); - constexpr cc::const_vector vo2c(vo2); - constexpr cc::const_vector vo3(const_cast&&>(vo1)); - constexpr cc::const_vector vo4(const_cast&&>(vo2)); - - ASSERT(vo3._len == vo1c._len) - ASSERT(vo4._len == vo2c._len) - ASSERT(vo3._size == vo1c._size) - ASSERT(vo4._size == vo2c._size) - ASSERT_VEC_EQ(vo3, vo1c) - ASSERT_VEC_EQ(vo4, vo2c) - - - return true; - } - - static consteval bool test_operator_eq() { - -#pragma message("Testing operator=") - - constexpr auto applicator = [] () consteval { - constexpr auto &arr1 = test_defs::get::template arr<1>(); - constexpr auto &arr2 = test_defs::get::template arr<2>(); - constexpr auto arr1_len = test_defs::get::template arr_len<1>(); - constexpr auto arr2_len = test_defs::get::template arr_len<2>(); - constexpr auto arr1_cap = test_defs::get::template capacity<1>(); - constexpr auto arr2_cap = test_defs::get::template capacity<2>(); - cc::const_vector v1o(arr1); - cc::const_vector v2o(arr2); - struct { - decltype(v1o) v1cs; - decltype(v2o) v2cs; - cc::const_vector v1cd; - cc::const_vector v2cd; - decltype(v1o) v1m; - decltype(v2o) v2m; - cc::const_vector v1a; - cc::const_vector v2a; - cc::const_vector v1i; - cc::const_vector v2i; - } ret; - ret.v1cs = v1o; - ret.v2cs = v2o; - ret.v1cd = v1o; - ret.v2cd = v2o; - ret.v1m = const_cast &&>(v1o); - ret.v2m = const_cast &&>(v2o); - ret.v1a = arr1; - ret.v2a = arr2; - ret.v1i = test_defs::get::template i_list<1>(); - ret.v2i = test_defs::get::template i_list<2>(); - - return ret; - }; - - constexpr auto int_res = applicator.operator()(); - constexpr auto char_res = applicator.operator()(); - constexpr auto string_res = applicator.operator()(); - constexpr auto obj_res = applicator.operator()(); - - ASSERT(int_res.v1cs._len == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2cs._len == VI_TEST_ARR2_LEN) - ASSERT(int_res.v1cs._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2cs._size == VI_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(int_res.v1cs, C_VI_TEST_ARR1) - ASSERT_VEC_ARR_EQ(int_res.v2cs, C_VI_TEST_ARR2) - ASSERT(int_res.v1cd._len == TEST_VEC1_CAPACITY) - ASSERT(int_res.v2cd._len == TEST_VEC2_CAPACITY) - ASSERT(int_res.v1cd._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2cd._size == VI_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(int_res.v1cd, C_VI_TEST_ARR1) - ASSERT_VEC_ARR_EQ(int_res.v2cd, C_VI_TEST_ARR2) - ASSERT(int_res.v1m._len == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2m._len == VI_TEST_ARR2_LEN) - ASSERT(int_res.v1m._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2m._size == VI_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(int_res.v1m, C_VI_TEST_ARR1) - ASSERT_VEC_ARR_EQ(int_res.v2m, C_VI_TEST_ARR2) - ASSERT(int_res.v1a._len == TEST_VEC1_CAPACITY) - ASSERT(int_res.v2a._len == TEST_VEC2_CAPACITY) - ASSERT(int_res.v1a._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2a._size == VI_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(int_res.v1a, C_VI_TEST_ARR1) - ASSERT_VEC_ARR_EQ(int_res.v2a, C_VI_TEST_ARR2) - ASSERT(int_res.v1i._len == TEST_VEC1_CAPACITY) - ASSERT(int_res.v2i._len == TEST_VEC2_CAPACITY) - ASSERT(int_res.v1i._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2i._size == VI_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(int_res.v1i, C_VI_TEST_ARR1) - ASSERT_VEC_ARR_EQ(int_res.v2i, C_VI_TEST_ARR2) - - ASSERT(char_res.v1cs._len == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2cs._len == VC_TEST_ARR2_LEN) - ASSERT(char_res.v1cs._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2cs._size == VC_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(char_res.v1cs, C_VC_TEST_ARR1) - ASSERT_VEC_ARR_EQ(char_res.v2cs, C_VC_TEST_ARR2) - ASSERT(char_res.v1cd._len == TEST_VEC1_CAPACITY) - ASSERT(char_res.v2cd._len == TEST_VEC2_CAPACITY) - ASSERT(char_res.v1cd._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2cd._size == VC_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(char_res.v1cd, C_VC_TEST_ARR1) - ASSERT_VEC_ARR_EQ(char_res.v2cd, C_VC_TEST_ARR2) - ASSERT(char_res.v1m._len == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2m._len == VC_TEST_ARR2_LEN) - ASSERT(char_res.v1m._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2m._size == VC_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(char_res.v1m, C_VC_TEST_ARR1) - ASSERT_VEC_ARR_EQ(char_res.v2m, C_VC_TEST_ARR2) - ASSERT(char_res.v1a._len == TEST_VEC1_CAPACITY) - ASSERT(char_res.v2a._len == TEST_VEC2_CAPACITY) - ASSERT(char_res.v1a._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2a._size == VC_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(char_res.v1a, C_VC_TEST_ARR1) - ASSERT_VEC_ARR_EQ(char_res.v2a, C_VC_TEST_ARR2) - ASSERT(char_res.v1i._len == TEST_VEC1_CAPACITY) - ASSERT(char_res.v2i._len == TEST_VEC2_CAPACITY) - ASSERT(char_res.v1i._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2i._size == VC_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(char_res.v1i, C_VC_TEST_ARR1) - ASSERT_VEC_ARR_EQ(char_res.v2i, C_VC_TEST_ARR2) - - ASSERT(string_res.v1cs._len == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2cs._len == VS_TEST_ARR2_LEN) - ASSERT(string_res.v1cs._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2cs._size == VS_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(string_res.v1cs, C_VS_TEST_ARR1) - ASSERT_VEC_ARR_EQ(string_res.v2cs, C_VS_TEST_ARR2) - ASSERT(string_res.v1cd._len == TEST_VEC1_CAPACITY) - ASSERT(string_res.v2cd._len == TEST_VEC2_CAPACITY) - ASSERT(string_res.v1cd._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2cd._size == VS_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(string_res.v1cd, C_VS_TEST_ARR1) - ASSERT_VEC_ARR_EQ(string_res.v2cd, C_VS_TEST_ARR2) - ASSERT(string_res.v1m._len == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2m._len == VS_TEST_ARR2_LEN) - ASSERT(string_res.v1m._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2m._size == VS_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(string_res.v1m, C_VS_TEST_ARR1) - ASSERT_VEC_ARR_EQ(string_res.v2m, C_VS_TEST_ARR2) - ASSERT(string_res.v1a._len == TEST_VEC1_CAPACITY) - ASSERT(string_res.v2a._len == TEST_VEC2_CAPACITY) - ASSERT(string_res.v1a._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2a._size == VS_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(string_res.v1a, C_VS_TEST_ARR1) - ASSERT_VEC_ARR_EQ(string_res.v2a, C_VS_TEST_ARR2) - ASSERT(string_res.v1i._len == TEST_VEC1_CAPACITY) - ASSERT(string_res.v2i._len == TEST_VEC2_CAPACITY) - ASSERT(string_res.v1i._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2i._size == VS_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(string_res.v1i, C_VS_TEST_ARR1) - ASSERT_VEC_ARR_EQ(string_res.v2i, C_VS_TEST_ARR2) - - ASSERT(obj_res.v1cs._len == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2cs._len == VO_TEST_ARR2_LEN) - ASSERT(obj_res.v1cs._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2cs._size == VO_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(obj_res.v1cs, C_VO_TEST_ARR1) - ASSERT_VEC_ARR_EQ(obj_res.v2cs, C_VO_TEST_ARR2) - ASSERT(obj_res.v1cd._len == TEST_VEC1_CAPACITY) - ASSERT(obj_res.v2cd._len == TEST_VEC2_CAPACITY) - ASSERT(obj_res.v1cd._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2cd._size == VO_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(obj_res.v1cd, C_VO_TEST_ARR1) - ASSERT_VEC_ARR_EQ(obj_res.v2cd, C_VO_TEST_ARR2) - ASSERT(obj_res.v1m._len == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2m._len == VO_TEST_ARR2_LEN) - ASSERT(obj_res.v1m._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2m._size == VO_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(obj_res.v1m, C_VO_TEST_ARR1) - ASSERT_VEC_ARR_EQ(obj_res.v2m, C_VO_TEST_ARR2) - ASSERT(obj_res.v1a._len == TEST_VEC1_CAPACITY) - ASSERT(obj_res.v2a._len == TEST_VEC2_CAPACITY) - ASSERT(obj_res.v1a._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2a._size == VO_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(obj_res.v1a, C_VO_TEST_ARR1) - ASSERT_VEC_ARR_EQ(obj_res.v2a, C_VO_TEST_ARR2) - ASSERT(obj_res.v1i._len == TEST_VEC1_CAPACITY) - ASSERT(obj_res.v2i._len == TEST_VEC2_CAPACITY) - ASSERT(obj_res.v1i._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2i._size == VO_TEST_ARR2_LEN) - ASSERT_VEC_ARR_EQ(obj_res.v1i, C_VO_TEST_ARR1) - ASSERT_VEC_ARR_EQ(obj_res.v2i, C_VO_TEST_ARR2) - - - return true; - } - - static consteval bool test_assign() { - -#pragma message("Testing assign()") - - constexpr auto applicator = [] () consteval { - constexpr auto &arr1 = test_defs::get::template arr<1>(); - constexpr auto &arr2 = test_defs::get::template arr<2>(); - constexpr auto arr1_len = test_defs::get::template arr_len<1>(); - constexpr auto arr2_len = test_defs::get::template arr_len<2>(); - constexpr auto arr1_cap = test_defs::get::template capacity<1>(); - constexpr auto arr2_cap = test_defs::get::template capacity<2>(); - cc::const_vector v1o(arr1); - cc::const_vector v2o(arr2); - struct { - cc::const_vector v1v; - cc::const_vector v2v; - cc::const_vector vvo; - cc::const_vector v1it; - cc::const_vector v2it; - cc::const_vector v1i; - cc::const_vector v2i; - } ret; - - ret.v1v.assign(arr1_len, arr1[0]); - ret.v2v.assign(arr2_len, arr2[0]); - ret.vvo.assign(arr1_len, arr1[0]); - ret.v1it.assign(std::begin(arr1), std::end(arr1)); - ret.v2it.assign(std::begin(arr2), std::end(arr2)); - ret.v1i.assign(test_defs::get::template i_list<1>()); - ret.v2i.assign(test_defs::get::template i_list<2>()); - - return ret; - }; - - constexpr auto int_res = applicator.operator()(); - constexpr auto char_res = applicator.operator()(); - constexpr auto string_res = applicator.operator()(); - constexpr auto obj_res = applicator.operator()(); - - ASSERT(int_res.v1v._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2v._size == VI_TEST_ARR2_LEN) - ASSERT_ALL_EQ(int_res.v1v.begin(), int_res.v1v.end(), C_VI_TEST_ARR1[0]) - ASSERT_ALL_EQ(int_res.v2v.begin(), int_res.v2v.end(), C_VI_TEST_ARR2[0]) - ASSERT(int_res.vvo._size == int_res.vvo._len) - ASSERT_ALL_EQ(int_res.vvo.begin(), int_res.vvo.end(), C_VI_TEST_ARR1[0]) - ASSERT(int_res.v1it._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2it._size == VI_TEST_ARR2_LEN) - ASSERT_ARR_EQ(int_res.v1it.begin(), int_res.v1it.end(), C_VI_TEST_ARR1) - ASSERT_ARR_EQ(int_res.v2it.begin(), int_res.v2it.end(), C_VI_TEST_ARR2) - ASSERT(int_res.v1i._size == VI_TEST_ARR1_LEN) - ASSERT(int_res.v2i._size == VI_TEST_ARR2_LEN) - ASSERT_ARR_EQ(int_res.v1i.begin(), int_res.v1i.end(), C_VI_TEST_ARR1) - ASSERT_ARR_EQ(int_res.v2i.begin(), int_res.v2i.end(), C_VI_TEST_ARR2) - - ASSERT(char_res.v1v._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2v._size == VC_TEST_ARR2_LEN) - ASSERT_ALL_EQ(char_res.v1v.begin(), char_res.v1v.end(), C_VC_TEST_ARR1[0]) - ASSERT_ALL_EQ(char_res.v2v.begin(), char_res.v2v.end(), C_VC_TEST_ARR2[0]) - ASSERT(char_res.vvo._size == char_res.vvo._len) - ASSERT_ALL_EQ(char_res.vvo.begin(), char_res.vvo.end(), C_VC_TEST_ARR1[0]) - ASSERT(char_res.v1it._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2it._size == VC_TEST_ARR2_LEN) - ASSERT_ARR_EQ(char_res.v1it.begin(), char_res.v1it.end(), C_VC_TEST_ARR1) - ASSERT_ARR_EQ(char_res.v2it.begin(), char_res.v2it.end(), C_VC_TEST_ARR2) - ASSERT(char_res.v1i._size == VC_TEST_ARR1_LEN) - ASSERT(char_res.v2i._size == VC_TEST_ARR2_LEN) - ASSERT_ARR_EQ(char_res.v1i.begin(), char_res.v1i.end(), C_VC_TEST_ARR1) - ASSERT_ARR_EQ(char_res.v2i.begin(), char_res.v2i.end(), C_VC_TEST_ARR2) - - ASSERT(string_res.v1v._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2v._size == VS_TEST_ARR2_LEN) - ASSERT_ALL_EQ(string_res.v1v.begin(), string_res.v1v.end(), C_VS_TEST_ARR1[0]) - ASSERT_ALL_EQ(string_res.v2v.begin(), string_res.v2v.end(), C_VS_TEST_ARR2[0]) - ASSERT(string_res.vvo._size == string_res.vvo._len) - ASSERT_ALL_EQ(string_res.vvo.begin(), string_res.vvo.end(), C_VS_TEST_ARR1[0]) - ASSERT(string_res.v1it._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2it._size == VS_TEST_ARR2_LEN) - ASSERT_ARR_EQ(string_res.v1it.begin(), string_res.v1it.end(), C_VS_TEST_ARR1) - ASSERT_ARR_EQ(string_res.v2it.begin(), string_res.v2it.end(), C_VS_TEST_ARR2) - ASSERT(string_res.v1i._size == VS_TEST_ARR1_LEN) - ASSERT(string_res.v2i._size == VS_TEST_ARR2_LEN) - ASSERT_ARR_EQ(string_res.v1i.begin(), string_res.v1i.end(), C_VS_TEST_ARR1) - ASSERT_ARR_EQ(string_res.v2i.begin(), string_res.v2i.end(), C_VS_TEST_ARR2) - - ASSERT(obj_res.v1v._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2v._size == VO_TEST_ARR2_LEN) - ASSERT_ALL_EQ(obj_res.v1v.begin(), obj_res.v1v.end(), C_VO_TEST_ARR1[0]) - ASSERT_ALL_EQ(obj_res.v2v.begin(), obj_res.v2v.end(), C_VO_TEST_ARR2[0]) - ASSERT(obj_res.vvo._size == obj_res.vvo._len) - ASSERT_ALL_EQ(obj_res.vvo.begin(), obj_res.vvo.end(), C_VO_TEST_ARR1[0]) - ASSERT(obj_res.v1it._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2it._size == VO_TEST_ARR2_LEN) - ASSERT_ARR_EQ(obj_res.v1it.begin(), obj_res.v1it.end(), C_VO_TEST_ARR1) - ASSERT_ARR_EQ(obj_res.v2it.begin(), obj_res.v2it.end(), C_VO_TEST_ARR2) - ASSERT(obj_res.v1i._size == VO_TEST_ARR1_LEN) - ASSERT(obj_res.v2i._size == VO_TEST_ARR2_LEN) - ASSERT_ARR_EQ(obj_res.v1i.begin(), obj_res.v1i.end(), C_VO_TEST_ARR1) - ASSERT_ARR_EQ(obj_res.v2i.begin(), obj_res.v2i.end(), C_VO_TEST_ARR2) - - - return true; - } - - static consteval bool test_data_access() { - -#pragma message("Testing data access") - - 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); - - for (int i = 0; i < vi1.size(); i++) { - ASSERT(vi1.at(i) == C_VI_TEST_ARR1[i]); - } - - ASSERT(vi1.at(0) == C_VI_TEST_ARR1[0]) - ASSERT(vi2.at(0) == C_VI_TEST_ARR2[0]) - ASSERT(vi1.at(1) == C_VI_TEST_ARR1[1]) - ASSERT(vi2.at(1) == C_VI_TEST_ARR2[1]) - 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; - - } -}; - -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; - std::cout << "Test of copy constructors: " << test_const_vector::test_constructor_copy() << std::endl; - std::cout << "Test of move constructor: " << test_const_vector::test_constructor_move() << std::endl; - std::cout << "Test of operator=: " << test_const_vector::test_operator_eq() << std::endl; - std::cout << "Test of assign(): " << test_const_vector::test_assign() << std::endl; - - return 0; -} - -#pragma clang diagnostic pop \ No newline at end of file