1019 lines
46 KiB
C++
1019 lines
46 KiB
C++
#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; }
|
|
};
|
|
|
|
|
|
class test_defs {
|
|
|
|
public:
|
|
|
|
#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 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 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 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);
|
|
|
|
template<typename T>
|
|
struct get_test_def {
|
|
template<unsigned long long int nr>
|
|
static consteval auto& get_arr_for_type();
|
|
|
|
template<unsigned long long int nr>
|
|
static consteval unsigned long long int get_arr_len_for_type();
|
|
};
|
|
|
|
};
|
|
|
|
using int_defs = test_defs::get_test_def<int>;
|
|
using char_defs = test_defs::get_test_def<char>;
|
|
using string_defs = test_defs::get_test_def<const char *>;
|
|
using obj_defs = test_defs::get_test_def<TestStruct>;
|
|
|
|
|
|
template<> template<> consteval auto& int_defs::get_arr_for_type<1>() { return C_VI_TEST_ARR1; }
|
|
template<> template<> consteval auto& int_defs::get_arr_for_type<2>() { return C_VI_TEST_ARR2; }
|
|
template<> template<> consteval auto& char_defs::get_arr_for_type<1>() { return C_VC_TEST_ARR1; }
|
|
template<> template<> consteval auto& char_defs::get_arr_for_type<2>() { return C_VC_TEST_ARR2; }
|
|
template<> template<> consteval auto& string_defs::get_arr_for_type<1>() { return C_VS_TEST_ARR1; }
|
|
template<> template<> consteval auto& string_defs::get_arr_for_type<2>() { return C_VS_TEST_ARR2; }
|
|
template<> template<> consteval auto& obj_defs::get_arr_for_type<1>() { return C_VO_TEST_ARR1; }
|
|
template<> template<> consteval auto& obj_defs::get_arr_for_type<2>() { return C_VO_TEST_ARR2; }
|
|
|
|
template<> template<> consteval std::size_t int_defs::get_arr_len_for_type<1>() { return VI_TEST_ARR1_LEN; }
|
|
template<> template<> consteval std::size_t int_defs::get_arr_len_for_type<2>() { return VI_TEST_ARR2_LEN; }
|
|
template<> template<> consteval std::size_t char_defs::get_arr_len_for_type<1>() { return VC_TEST_ARR1_LEN; }
|
|
template<> template<> consteval std::size_t char_defs::get_arr_len_for_type<2>() { return VC_TEST_ARR2_LEN; }
|
|
template<> template<> consteval std::size_t string_defs::get_arr_len_for_type<1>() { return VS_TEST_ARR1_LEN; }
|
|
template<> template<> consteval std::size_t string_defs::get_arr_len_for_type<2>() { return VS_TEST_ARR2_LEN; }
|
|
template<> template<> consteval std::size_t obj_defs::get_arr_len_for_type<1>() { return VO_TEST_ARR1_LEN; }
|
|
template<> template<> consteval std::size_t obj_defs::get_arr_len_for_type<2>() { return VO_TEST_ARR2_LEN; }
|
|
|
|
|
|
|
|
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 int_applicator = []()consteval {
|
|
constexpr auto &arr1 = int_defs::get_arr_for_type<1>();
|
|
constexpr auto &arr2 = int_defs::get_arr_for_type<2>();
|
|
constexpr auto arr1_len = int_defs::get_arr_len_for_type<1>();
|
|
constexpr auto arr2_len = int_defs::get_arr_len_for_type<2>();
|
|
cc::const_vector v1o(arr1);
|
|
cc::const_vector v2o(arr2);
|
|
struct {
|
|
decltype(v1o) v1cs;
|
|
decltype(v2o) v2cs;
|
|
cc::const_vector<int, 5> v1cd;
|
|
cc::const_vector<int, 10> v2cd;
|
|
decltype(v1o) v1m;
|
|
decltype(v2o) v2m;
|
|
cc::const_vector<int, 5> v1a;
|
|
cc::const_vector<int, 10> v2a;
|
|
cc::const_vector<int, 5> v1i;
|
|
cc::const_vector<int, 10> v2i;
|
|
} ret;
|
|
ret.v1cs = v1o;
|
|
ret.v2cs = v2o;
|
|
ret.v1cd = v1o;
|
|
ret.v2cd = v2o;
|
|
ret.v1m = const_cast<cc::const_vector<decltype(v1o)::value_type, decltype(v1o)::_len> &&>(v1o);
|
|
ret.v2m = const_cast<cc::const_vector<decltype(v2o)::value_type, decltype(v2o)::_len> &&>(v2o);
|
|
ret.v1a = arr1;
|
|
ret.v2a = arr2;
|
|
ret.v1i = VI_TEST_ARR1;
|
|
ret.v2i = VI_TEST_ARR2;
|
|
return ret;
|
|
};
|
|
constexpr auto char_applicator = []()consteval {
|
|
constexpr auto &arr1 = char_defs::get_arr_for_type<1>();
|
|
constexpr auto &arr2 = char_defs::get_arr_for_type<2>();
|
|
constexpr auto arr1_len = char_defs::get_arr_len_for_type<1>();
|
|
constexpr auto arr2_len = char_defs::get_arr_len_for_type<2>();
|
|
cc::const_vector v1o(arr1);
|
|
cc::const_vector v2o(arr2);
|
|
struct {
|
|
decltype(v1o) v1cs;
|
|
decltype(v2o) v2cs;
|
|
cc::const_vector<char, 5> v1cd;
|
|
cc::const_vector<char, 10> v2cd;
|
|
decltype(v1o) v1m;
|
|
decltype(v2o) v2m;
|
|
cc::const_vector<char, 5> v1a;
|
|
cc::const_vector<char, 10> v2a;
|
|
cc::const_vector<char, 5> v1i;
|
|
cc::const_vector<char, 10> v2i;
|
|
} ret;
|
|
ret.v1cs = v1o;
|
|
ret.v2cs = v2o;
|
|
ret.v1cd = v1o;
|
|
ret.v2cd = v2o;
|
|
ret.v1m = const_cast<cc::const_vector<decltype(v1o)::value_type, decltype(v1o)::_len> &&>(v1o);
|
|
ret.v2m = const_cast<cc::const_vector<decltype(v2o)::value_type, decltype(v2o)::_len> &&>(v2o);
|
|
ret.v1a = arr1;
|
|
ret.v2a = arr2;
|
|
ret.v1i = VC_TEST_ARR1;
|
|
ret.v2i = VC_TEST_ARR2;
|
|
return ret;
|
|
};
|
|
constexpr auto string_applicator = []()consteval {
|
|
constexpr auto &arr1 = string_defs::get_arr_for_type<1>();
|
|
constexpr auto &arr2 = string_defs::get_arr_for_type<2>();
|
|
constexpr auto arr1_len = string_defs::get_arr_len_for_type<1>();
|
|
constexpr auto arr2_len = string_defs::get_arr_len_for_type<2>();
|
|
cc::const_vector v1o(arr1);
|
|
cc::const_vector v2o(arr2);
|
|
struct {
|
|
decltype(v1o) v1cs;
|
|
decltype(v2o) v2cs;
|
|
cc::const_vector<const char *, 5> v1cd;
|
|
cc::const_vector<const char *, 10> v2cd;
|
|
decltype(v1o) v1m;
|
|
decltype(v2o) v2m;
|
|
cc::const_vector<const char *, 5> v1a;
|
|
cc::const_vector<const char *, 10> v2a;
|
|
cc::const_vector<const char *, 5> v1i;
|
|
cc::const_vector<const char *, 10> v2i;
|
|
} ret;
|
|
ret.v1cs = v1o;
|
|
ret.v2cs = v2o;
|
|
ret.v1cd = v1o;
|
|
ret.v2cd = v2o;
|
|
ret.v1m = const_cast<cc::const_vector<decltype(v1o)::value_type, decltype(v1o)::_len> &&>(v1o);
|
|
ret.v2m = const_cast<cc::const_vector<decltype(v2o)::value_type, decltype(v2o)::_len> &&>(v2o);
|
|
ret.v1a = arr1;
|
|
ret.v2a = arr2;
|
|
ret.v1i = VS_TEST_ARR1;
|
|
ret.v2i = VS_TEST_ARR2;
|
|
return ret;
|
|
};
|
|
constexpr auto obj_applicator = []()consteval {
|
|
constexpr auto &arr1 = obj_defs::get_arr_for_type<1>();
|
|
constexpr auto &arr2 = obj_defs::get_arr_for_type<2>();
|
|
constexpr auto arr1_len = obj_defs::get_arr_len_for_type<1>();
|
|
constexpr auto arr2_len = obj_defs::get_arr_len_for_type<2>();
|
|
cc::const_vector v1o(arr1);
|
|
cc::const_vector v2o(arr2);
|
|
struct {
|
|
decltype(v1o) v1cs;
|
|
decltype(v2o) v2cs;
|
|
cc::const_vector<TestStruct, 5> v1cd;
|
|
cc::const_vector<TestStruct, 10> v2cd;
|
|
decltype(v1o) v1m;
|
|
decltype(v2o) v2m;
|
|
cc::const_vector<TestStruct, 5> v1a;
|
|
cc::const_vector<TestStruct, 10> v2a;
|
|
cc::const_vector<TestStruct, 5> v1i;
|
|
cc::const_vector<TestStruct, 10> v2i;
|
|
} ret;
|
|
ret.v1cs = v1o;
|
|
ret.v2cs = v2o;
|
|
ret.v1cd = v1o;
|
|
ret.v2cd = v2o;
|
|
ret.v1m = const_cast<cc::const_vector<decltype(v1o)::value_type, decltype(v1o)::_len> &&>(v1o);
|
|
ret.v2m = const_cast<cc::const_vector<decltype(v2o)::value_type, decltype(v2o)::_len> &&>(v2o);
|
|
ret.v1a = arr1;
|
|
ret.v2a = arr2;
|
|
ret.v1i = VO_TEST_ARR1;
|
|
ret.v2i = VO_TEST_ARR2;
|
|
return ret;
|
|
};
|
|
|
|
constexpr auto int_res = int_applicator();
|
|
constexpr auto char_res = char_applicator();
|
|
constexpr auto string_res = string_applicator();
|
|
constexpr auto obj_res = obj_applicator();
|
|
|
|
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;
|
|
}
|
|
|
|
};
|
|
|
|
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 move constructor: " << test_const_vector::test_operator_eq() << std::endl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#pragma clang diagnostic pop |