#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._len, eq)
#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_ARR_EQ((vec._arr + startI), (vec._arr + endI), eq)


class test_const_vector {
		
	public:
		
		struct TestStruct {
			int x = 0;
			char c = 0;
			const char * s = "This is a string";

			constexpr bool operator==(const TestStruct &other) const { return x == other.x && c == other.c && std::string_view(s) == other.s; }
		};

#define GEN_TEST_STRUCT_ARR(nr, i) TestStruct(C_VI_TEST_ARR##nr[i], C_VC_TEST_ARR##nr[i], C_VS_TEST_ARR##nr[i])

		
#define TEST_VEC1_CAPACITY 5
#define TEST_VEC2_CAPACITY 10

#define TEST_VEC1_SIZE  3
#define TEST_VEC2_SIZE  7

#define VI_TEST_VAL     5
#define VC_TEST_VAL     'T'
#define VS_TEST_VAL     "Test string"
#define VO_TEST_VAL     TestStruct(VI_TEST_VAL, VC_TEST_VAL, VS_TEST_VAL)

#define VI_TEST_ARR1	{ 1, 2, 3, 4 }
#define VI_TEST_ARR2 	{ 5, 6, 7, 8, 9, 10, 11, 12 }
		static constexpr const int C_VI_TEST_ARR1[] = VI_TEST_ARR1;
		static constexpr const int C_VI_TEST_ARR2[] = VI_TEST_ARR2;
		static constexpr const std::array STD_VI_TEST_ARR1 = VI_TEST_ARR1;
		static constexpr const std::array STD_VI_TEST_ARR2 = VI_TEST_ARR2;
		static constexpr const std::size_t VI_TEST_ARR1_LEN = C_ARR_LEN(C_VI_TEST_ARR1);
		static constexpr const std::size_t VI_TEST_ARR2_LEN = C_ARR_LEN(C_VI_TEST_ARR2);

#define VC_TEST_ARR1	{ 'a', 'B', 'c', 'D' }
#define VC_TEST_ARR2 	{ 'e', 'F', 'g', 'H', 'i', 'J', '\n', '\0' }
		static constexpr const char C_VC_TEST_ARR1[] = VC_TEST_ARR1;
		static constexpr const char C_VC_TEST_ARR2[] = VC_TEST_ARR2;
		static constexpr const std::array STD_VC_TEST_ARR1 = VC_TEST_ARR1;
		static constexpr const std::array STD_VC_TEST_ARR2 = VC_TEST_ARR2;
		static constexpr const std::size_t VC_TEST_ARR1_LEN = C_ARR_LEN(C_VC_TEST_ARR1);
		static constexpr const std::size_t VC_TEST_ARR2_LEN = C_ARR_LEN(C_VC_TEST_ARR2);

#define VS_TEST_ARR1	{ "Lorem", "ipsum", "dolor", "sit" }
#define VS_TEST_ARR2 	{ "amet", "consetetur", "sadipscing", "elitr", "sed", "diam", "nonumy", "eirmod", "tempor", "\0" }
		static constexpr const char * C_VS_TEST_ARR1[] = VS_TEST_ARR1;
		static constexpr const char * C_VS_TEST_ARR2[] = VS_TEST_ARR2;
		static constexpr const std::array STD_VS_TEST_ARR1 = VS_TEST_ARR1;
		static constexpr const std::array STD_VS_TEST_ARR2 = VS_TEST_ARR2;
		static constexpr const std::size_t VS_TEST_ARR1_LEN = C_ARR_LEN(C_VS_TEST_ARR1);
		static constexpr const std::size_t VS_TEST_ARR2_LEN = C_ARR_LEN(C_VS_TEST_ARR2);

#define VO_TEST_ARR1	{ GEN_TEST_STRUCT_ARR(1, 0), \
                          GEN_TEST_STRUCT_ARR(1, 1), \
                          GEN_TEST_STRUCT_ARR(1, 2), \
                          GEN_TEST_STRUCT_ARR(1, 3) }
#define VO_TEST_ARR2 	{ GEN_TEST_STRUCT_ARR(2, 0), \
                          GEN_TEST_STRUCT_ARR(2, 1), \
                          GEN_TEST_STRUCT_ARR(2, 2), \
                          GEN_TEST_STRUCT_ARR(2, 3), \
                          GEN_TEST_STRUCT_ARR(2, 4), \
                          GEN_TEST_STRUCT_ARR(2, 5), \
                          GEN_TEST_STRUCT_ARR(2, 6), \
                          GEN_TEST_STRUCT_ARR(2, 7) }
		static constexpr TestStruct C_VO_TEST_ARR1[] = VO_TEST_ARR1;
		static constexpr TestStruct C_VO_TEST_ARR2[] = VO_TEST_ARR2;
		static constexpr const std::array STD_VO_TEST_ARR1 = VO_TEST_ARR1;
		static constexpr const std::array STD_VO_TEST_ARR2 = VO_TEST_ARR2;
		static constexpr const std::size_t VO_TEST_ARR1_LEN = C_ARR_LEN(C_VO_TEST_ARR1);
		static constexpr const std::size_t VO_TEST_ARR2_LEN = C_ARR_LEN(C_VO_TEST_ARR2);
		
		
		static consteval bool test_constructor_default() {

#pragma message("Testing default constructor")

			constexpr cc::const_vector<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;
		}

};

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;
	
	
	return 0;
}

#pragma clang diagnostic pop