556 lines
24 KiB
C++
556 lines
24 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._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 |