#include <string>
#include <iostream>
#include <array>

#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, [] <typename T> (const T& e) { constexpr T eqv = eq; if constexpr (std::is_same_v<const char *, T>) { 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, [] <typename T> (const T& a, const T& b) { if constexpr (std::is_same_v<const char *, T>) { 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<int> VI_I_LIST1 = VI_TEST_ARR1;
	static constexpr std::initializer_list<int> 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<char> VC_I_LIST1 = VC_TEST_ARR1;
	static constexpr std::initializer_list<char> 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<const char *> VS_I_LIST1 = VS_TEST_ARR1;
	static constexpr std::initializer_list<const char *> 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<TestStruct> VO_I_LIST1 = VO_TEST_ARR1;
	static constexpr std::initializer_list<TestStruct> VO_I_LIST2 = VO_TEST_ARR2;

	template<typename T>
	struct get {
		template<std::size_t nr>
		static consteval auto& i_list();
		
		template<std::size_t nr>
		static consteval auto & arr();

		template<std::size_t nr>
		static consteval std::size_t arr_len();
		
		template<std::size_t nr>
		static consteval std::size_t capacity();
		
	};

};

template<typename T>
template<std::size_t nr>
consteval auto & test_defs::get<T>::i_list() { return nullptr; }
template<typename T>
template<std::size_t nr>
consteval auto & test_defs::get<T>::arr() { return nullptr; }
template<typename T>
template<std::size_t nr>
consteval std::size_t test_defs::get<T>::arr_len() { return 0; }
template<typename T>
template<std::size_t nr>
consteval std::size_t test_defs::get<T>::capacity() { return 0; }


template<> template<> consteval auto & test_defs::get<int>::i_list<1>() { return VI_I_LIST1; }
template<> template<> consteval auto & test_defs::get<int>::i_list<2>() { return VI_I_LIST2; }
template<> template<> consteval auto & test_defs::get<char>::i_list<1>() { return VC_I_LIST1; }
template<> template<> consteval auto & test_defs::get<char>::i_list<2>() { return VC_I_LIST2; }
template<> template<> consteval auto & test_defs::get<const char *>::i_list<1>() { return VS_I_LIST1; }
template<> template<> consteval auto & test_defs::get<const char *>::i_list<2>() { return VS_I_LIST2; }
template<> template<> consteval auto & test_defs::get<TestStruct>::i_list<1>() { return VO_I_LIST1; }
template<> template<> consteval auto & test_defs::get<TestStruct>::i_list<2>() { return VO_I_LIST2; }

template<> template<> consteval auto & test_defs::get<int>::arr<1>() { return C_VI_TEST_ARR1; }
template<> template<> consteval auto & test_defs::get<int>::arr<2>() { return C_VI_TEST_ARR2; }
template<> template<> consteval auto & test_defs::get<char>::arr<1>() { return C_VC_TEST_ARR1; }
template<> template<> consteval auto & test_defs::get<char>::arr<2>() { return C_VC_TEST_ARR2; }
template<> template<> consteval auto & test_defs::get<const char*>::arr<1>() { return C_VS_TEST_ARR1; }
template<> template<> consteval auto & test_defs::get<const char*>::arr<2>() { return C_VS_TEST_ARR2; }
template<> template<> consteval auto & test_defs::get<TestStruct>::arr<1>() { return C_VO_TEST_ARR1; }
template<> template<> consteval auto & test_defs::get<TestStruct>::arr<2>() { return C_VO_TEST_ARR2; }

template<> template<> consteval std::size_t test_defs::get<int>::arr_len<1>() { return VI_TEST_ARR1_LEN; }
template<> template<> consteval std::size_t test_defs::get<int>::arr_len<2>() { return VI_TEST_ARR2_LEN; }
template<> template<> consteval std::size_t test_defs::get<char>::arr_len<1>() { return VC_TEST_ARR1_LEN; }
template<> template<> consteval std::size_t test_defs::get<char>::arr_len<2>() { return VC_TEST_ARR2_LEN; }
template<> template<> consteval std::size_t test_defs::get<const char *>::arr_len<1>() { return VS_TEST_ARR1_LEN; }
template<> template<> consteval std::size_t test_defs::get<const char *>::arr_len<2>() { return VS_TEST_ARR2_LEN; }
template<> template<> consteval std::size_t test_defs::get<TestStruct>::arr_len<1>() { return VO_TEST_ARR1_LEN; }
template<> template<> consteval std::size_t test_defs::get<TestStruct>::arr_len<2>() { return VO_TEST_ARR2_LEN; }

template<> template<> consteval std::size_t test_defs::get<int>::capacity<1>() { return TEST_VEC1_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<int>::capacity<2>() { return TEST_VEC2_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<char>::capacity<1>() { return TEST_VEC1_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<char>::capacity<2>() { return TEST_VEC2_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<const char *>::capacity<1>() { return TEST_VEC1_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<const char *>::capacity<2>() { return TEST_VEC2_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<TestStruct>::capacity<1>() { return TEST_VEC1_CAPACITY; }
template<> template<> consteval std::size_t test_defs::get<TestStruct>::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<int, TEST_VEC1_CAPACITY> vi1;
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc1;
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs1;
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo1;
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<int, TEST_VEC1_CAPACITY> vi1(VI_TEST_VAL);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc1(VC_TEST_VAL);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs1(VS_TEST_VAL);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo1(VO_TEST_VAL);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<int, TEST_VEC1_CAPACITY> vi1(TEST_VEC1_SIZE, VI_TEST_VAL);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc1(TEST_VEC1_SIZE, VC_TEST_VAL);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs1(TEST_VEC1_SIZE, VS_TEST_VAL);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo1(TEST_VEC1_SIZE, VO_TEST_VAL);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<int, TEST_VEC1_CAPACITY> vi3(C_VI_TEST_ARR1);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc3(C_VC_TEST_ARR1);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs3(C_VS_TEST_ARR1);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo3(C_VO_TEST_ARR1);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<value_type> list)'")

			constexpr cc::const_vector vi1(VI_TEST_ARR1);
			constexpr cc::const_vector vi2(VI_TEST_ARR2);
			constexpr cc::const_vector<int, TEST_VEC1_CAPACITY> vi3(VI_TEST_ARR1);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc3(VC_TEST_ARR1);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs3(VS_TEST_ARR1);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo3(VO_TEST_ARR1);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<int, TEST_VEC1_CAPACITY> vi1(std::begin(C_VI_TEST_ARR1), std::end(C_VI_TEST_ARR1));
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> vi2(std::begin(C_VI_TEST_ARR2), std::end(C_VI_TEST_ARR2));
			constexpr cc::const_vector<int, TEST_VEC1_CAPACITY> vi3(STD_VI_TEST_ARR1.begin(), STD_VI_TEST_ARR1.end());
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc1(std::begin(C_VC_TEST_ARR1), std::end(C_VC_TEST_ARR1));
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> vc2(std::begin(C_VC_TEST_ARR2), std::end(C_VC_TEST_ARR2));
			constexpr cc::const_vector<char, TEST_VEC1_CAPACITY> vc3(STD_VC_TEST_ARR1.begin(), STD_VC_TEST_ARR1.end());
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs1(std::begin(C_VS_TEST_ARR1), std::end(C_VS_TEST_ARR1));
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> vs2(std::begin(C_VS_TEST_ARR2), std::end(C_VS_TEST_ARR2));
			constexpr cc::const_vector<const char *, TEST_VEC1_CAPACITY> vs3(STD_VS_TEST_ARR1.begin(), STD_VS_TEST_ARR1.end());
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo1(std::begin(C_VO_TEST_ARR1), std::end(C_VO_TEST_ARR1));
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> vo2(std::begin(C_VO_TEST_ARR2), std::end(C_VO_TEST_ARR2));
			constexpr cc::const_vector<TestStruct, TEST_VEC1_CAPACITY> vo3(STD_VO_TEST_ARR1.begin(), STD_VO_TEST_ARR1.end());
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<int, TEST_VEC1_CAPACITY> vi3(vi1);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc3(vc1);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs3(vs1);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo3(vo1);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<cc::const_vector<int, decltype(vi1)::_len>&&>(vi1));
			constexpr cc::const_vector vi4(const_cast<cc::const_vector<int, decltype(vi2)::_len>&&>(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<cc::const_vector<char, decltype(vc1)::_len>&&>(vc1));
			constexpr cc::const_vector vc4(const_cast<cc::const_vector<char, decltype(vc2)::_len>&&>(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<cc::const_vector<const char *, decltype(vs1)::_len>&&>(vs1));
			constexpr cc::const_vector vs4(const_cast<cc::const_vector<const char *, decltype(vs2)::_len>&&>(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<cc::const_vector<TestStruct, decltype(vo1)::_len>&&>(vo1));
			constexpr cc::const_vector vo4(const_cast<cc::const_vector<TestStruct, decltype(vo2)::_len>&&>(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 = [] <typename T> () consteval {
				constexpr auto &arr1 = test_defs::get<T>::template arr<1>();
				constexpr auto &arr2 = test_defs::get<T>::template arr<2>();
				constexpr auto arr1_len = test_defs::get<T>::template arr_len<1>();
				constexpr auto arr2_len = test_defs::get<T>::template arr_len<2>();
				constexpr auto arr1_cap = test_defs::get<T>::template capacity<1>();
				constexpr auto arr2_cap = test_defs::get<T>::template capacity<2>();
				cc::const_vector v1o(arr1);
				cc::const_vector v2o(arr2);
				struct {
					decltype(v1o) v1cs;
					decltype(v2o) v2cs;
					cc::const_vector<T, arr1_cap> v1cd;
					cc::const_vector<T, arr2_cap> v2cd;
					decltype(v1o) v1m;
					decltype(v2o) v2m;
					cc::const_vector<T, arr1_cap> v1a;
					cc::const_vector<T, arr2_cap> v2a;
					cc::const_vector<T, arr1_cap> v1i;
					cc::const_vector<T, arr2_cap> v2i;
				} ret;
				ret.v1cs = v1o;
				ret.v2cs = v2o;
				ret.v1cd = v1o;
				ret.v2cd = v2o;
				ret.v1m = const_cast<cc::const_vector<typename decltype(v1o)::value_type, decltype(v1o)::_len> &&>(v1o);
				ret.v2m = const_cast<cc::const_vector<typename decltype(v2o)::value_type, decltype(v2o)::_len> &&>(v2o);
				ret.v1a = arr1;
				ret.v2a = arr2;
				ret.v1i = test_defs::get<T>::template i_list<1>();
				ret.v2i = test_defs::get<T>::template i_list<2>();
				
				return ret;
			};

			constexpr auto int_res = applicator.operator()<int>();
            constexpr auto char_res = applicator.operator()<char>();
            constexpr auto string_res = applicator.operator()<const char *>();
            constexpr auto obj_res = applicator.operator()<TestStruct>();

            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 = [] <typename T> () consteval {
				constexpr auto &arr1 = test_defs::get<T>::template arr<1>();
				constexpr auto &arr2 = test_defs::get<T>::template arr<2>();
				constexpr auto arr1_len = test_defs::get<T>::template arr_len<1>();
				constexpr auto arr2_len = test_defs::get<T>::template arr_len<2>();
				constexpr auto arr1_cap = test_defs::get<T>::template capacity<1>();
				constexpr auto arr2_cap = test_defs::get<T>::template capacity<2>();
				cc::const_vector v1o(arr1);
				cc::const_vector v2o(arr2);
				struct {
					cc::const_vector<T, arr1_cap> v1v;
					cc::const_vector<T, arr2_cap> v2v;
					cc::const_vector<T, 1> vvo;
					cc::const_vector<T, arr1_cap> v1it;
					cc::const_vector<T, arr2_cap> v2it;
					cc::const_vector<T, arr1_cap> v1i;
					cc::const_vector<T, arr2_cap> 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<T>::template i_list<1>());
				ret.v2i.assign(test_defs::get<T>::template i_list<2>());
				
				return ret;
			};

			constexpr auto int_res = applicator.operator()<int>();
            constexpr auto char_res = applicator.operator()<char>();
            constexpr auto string_res = applicator.operator()<const char *>();
            constexpr auto obj_res = applicator.operator()<TestStruct>();

            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<int, TEST_VEC1_CAPACITY> vi3(VI_TEST_ARR1);
			constexpr cc::const_vector<int, TEST_VEC2_CAPACITY> 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<char, TEST_VEC1_CAPACITY> vc3(VC_TEST_ARR1);
			constexpr cc::const_vector<char, TEST_VEC2_CAPACITY> 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<const char *, TEST_VEC1_CAPACITY> vs3(VS_TEST_ARR1);
			constexpr cc::const_vector<const char *, TEST_VEC2_CAPACITY> 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<TestStruct, TEST_VEC1_CAPACITY> vo3(VO_TEST_ARR1);
			constexpr cc::const_vector<TestStruct, TEST_VEC2_CAPACITY> 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<value_type> 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