updated constructor.test to use context
This commit is contained in:
parent
e17dcb2442
commit
fb01e7352a
|
|
@ -1,678 +1,165 @@
|
|||
#pragma clang diagnostic push
|
||||
#pragma ide diagnostic ignored "readability-container-size-empty"
|
||||
#include <const_vector.hpp>
|
||||
|
||||
#include "test.hpp"
|
||||
#include "test_params.h"
|
||||
#include "test_args.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#define ASSERT_TYPE_NUM_ALL_VEC_EQ(vec, eq, type, num) ASSERT_TYPE_NUM_ALL_EQ((vec).begin(), (vec).end(), eq, type, num)
|
||||
#define ASSERT_TYPE_NUM_RANGE_VEC_EQ(vec, startI, endI, eq, type, num) ASSERT_TYPE_NUM_ALL_EQ(((vec).data() + startI), ((vec).data() + endI), eq, type, num)
|
||||
#define ASSERT_TYPE_NUM_VEC_ARR_EQ(vec, eq, type, num) ASSERT_TYPE_NUM_C_ARR_EQ((vec).data(), (vec).data() + (vec).size(), std::begin(eq), type, num)
|
||||
#define ASSERT_TYPE_NUM_VEC_EQ(vec1, vec2, type, num) ASSERT_TYPE_NUM_C_ARR_EQ((vec1).data(), (vec1).data() + (vec1).size(), (vec2).data(), type, num)
|
||||
#define ASSERT_TYPE_NUM_RANGE_VEC_ARR_EQ(vec, startI, endI, eq, type, num) ASSERT_TYPE_NUM_C_ARR_EQ(((vec).begin() + startI), ((vec).begin() + endI), std::begin(eq), type, num)
|
||||
|
||||
#define ASSERT_TYPE_ALL_VEC_EQ(vec, eq, type) ASSERT_TYPE_ALL_EQ((vec).begin(), (vec).end(), eq, type)
|
||||
#define ASSERT_TYPE_RANGE_VEC_EQ(vec, startI, endI, eq, type) ASSERT_TYPE_ALL_EQ(((vec).data() + startI), ((vec).data() + endI), eq, type)
|
||||
#define ASSERT_TYPE_VEC_ARR_EQ(vec, eq, type) ASSERT_TYPE_C_ARR_EQ((vec).data(), (vec).data() + (vec).size(), std::begin(eq), type)
|
||||
#define ASSERT_TYPE_VEC_EQ(vec1, vec2, type) ASSERT_TYPE_C_ARR_EQ((vec1).data(), (vec1).data() + (vec1).size(), (vec2).data(), type)
|
||||
#define ASSERT_TYPE_RANGE_VEC_ARR_EQ(vec, startI, endI, eq, type) ASSERT_TYPE_C_ARR_EQ(((vec).begin() + startI), ((vec).begin() + endI), std::begin(eq), type)
|
||||
|
||||
#define ASSERT_ALL_VEC_EQ(vec, eq) ASSERT_TYPE_ALL_VEC_EQ(vec, eq, std::nullptr_t)
|
||||
#define ASSERT_RANGE_VEC_EQ(vec, startI, endI, eq) ASSERT_TYPE_RANGE_VEC_EQ(vec, startI, endI, eq, std::nullptr_t)
|
||||
#define ASSERT_VEC_ARR_EQ(vec, eq) ASSERT_TYPE_VEC_ARR_EQ(vec, eq, std::nullptr_t)
|
||||
#define ASSERT_VEC_EQ(vec1, vec2) ASSERT_TYPE_VEC_EQ(vec1, vec2, std::nullptr_t)
|
||||
#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_TYPE_RANGE_VEC_ARR_EQ(vec, startI, endI, eq, std::nullptr_t)
|
||||
|
||||
|
||||
constexpr test_suite tests = define_tests("Constructors")
|
||||
("const_vector()", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi1;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi2;
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() constexpr {
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi1.size() == 0);
|
||||
ASSERT(vi2.size() == 0);
|
||||
ASSERT(vi1.empty());
|
||||
ASSERT(vi2.empty());
|
||||
ASSERT_ALL_VEC_EQ(vi1, int());
|
||||
ASSERT_ALL_VEC_EQ(vi2, int());
|
||||
cc::const_vector<T, get_test_param<ctx, "capacity">()> v;
|
||||
|
||||
ASSERT((v.capacity() == get_test_param<ctx, "capacity">()), ctx);
|
||||
ASSERT(v.empty(), ctx);
|
||||
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc1;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc2;
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<char>::capacity<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<char>::capacity<2>());
|
||||
ASSERT(vc1.size() == 0);
|
||||
ASSERT(vc2.size() == 0);
|
||||
ASSERT(vc1.empty());
|
||||
ASSERT(vc2.empty());
|
||||
ASSERT_ALL_VEC_EQ(vc1, char());
|
||||
ASSERT_ALL_VEC_EQ(vc2, char());
|
||||
|
||||
|
||||
cc::const_vector<const char *, test_defs::get<const char*>::capacity<1>()> vs1;
|
||||
cc::const_vector<const char *, test_defs::get<const char*>::capacity<2>()> vs2;
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<const char*>::capacity<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<const char*>::capacity<2>());
|
||||
ASSERT(vs1.size() == 0);
|
||||
ASSERT(vs2.size() == 0);
|
||||
ASSERT(vs1.empty());
|
||||
ASSERT(vs2.empty());
|
||||
|
||||
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo1;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo2;
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<TestStruct>::capacity<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<TestStruct>::capacity<2>());
|
||||
ASSERT(vo1.size() == 0);
|
||||
ASSERT(vo2.size() == 0);
|
||||
ASSERT(vo1.empty());
|
||||
ASSERT(vo2.empty());
|
||||
ASSERT_ALL_VEC_EQ(vo1, TestStruct{});
|
||||
ASSERT_ALL_VEC_EQ(vo2, TestStruct{});
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(T &value)", []() constexpr {
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi1(test_defs::get<int>::value<1>());
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi2(test_defs::get<int>::value<2>());
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<char>::capacity<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<char>::capacity<2>());
|
||||
ASSERT_ALL_VEC_EQ(vi1, test_defs::get<int>::value<1>());
|
||||
ASSERT_ALL_VEC_EQ(vi2, test_defs::get<int>::value<2>());
|
||||
|
||||
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc1(test_defs::get<char>::value<1>());
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc2(test_defs::get<char>::value<2>());
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<char>::capacity<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<char>::capacity<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<char>::capacity<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::capacity<2>());
|
||||
ASSERT_ALL_VEC_EQ(vc1, test_defs::get<char>::value<1>());
|
||||
ASSERT_ALL_VEC_EQ(vc2, test_defs::get<char>::value<2>());
|
||||
|
||||
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<1>()> vs1(test_defs::get<const char *>::value<1>());
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<2>()> vs2(test_defs::get<const char *>::value<2>());
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<const char *>::capacity<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<const char *>::capacity<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<const char *>::capacity<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char *>::capacity<2>());
|
||||
ASSERT_ALL_VEC_EQ(vs1, test_defs::get<const char *>::value<1>());
|
||||
ASSERT_ALL_VEC_EQ(vs2, test_defs::get<const char *>::value<2>());
|
||||
|
||||
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo1(test_defs::get<TestStruct>::value<1>());
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo2(test_defs::get<TestStruct>::value<2>());
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<TestStruct>::capacity<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<TestStruct>::capacity<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::capacity<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::capacity<2>());
|
||||
ASSERT_ALL_VEC_EQ(vo1, test_defs::get<TestStruct>::value<1>());
|
||||
ASSERT_ALL_VEC_EQ(vo2, test_defs::get<TestStruct>::value<2>());
|
||||
return TEST_PASS();
|
||||
}), 2, int , char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(size_type size, T &value)", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi1(test_defs::get<int>::size<1>(), test_defs::get<int>::value<1>());
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi2(test_defs::get<int>::size<2>(), test_defs::get<int>::value<2>());
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() constexpr {
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<int>::size<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::size<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vi1, 0, test_defs::get<int>::size<1>(), test_defs::get<int>::value<1>());
|
||||
ASSERT_RANGE_VEC_EQ(vi1, test_defs::get<int>::size<1>(), test_defs::get<int>::capacity<1>(), int());
|
||||
ASSERT_RANGE_VEC_EQ(vi2, 0, test_defs::get<int>::size<2>(), test_defs::get<int>::value<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vi2, test_defs::get<int>::size<2>(), test_defs::get<int>::capacity<2>(), int());
|
||||
cc::const_vector<T, get_test_param<ctx, "capacity">()> v1(get_test_param<ctx, "capacity">(), get_test_param<ctx, "value">());
|
||||
cc::const_vector<T, get_test_param<ctx, "capacity">()> v2(get_test_param<ctx, "capacity">() / 2, get_test_param<ctx, "value">());
|
||||
|
||||
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc1(test_defs::get<int>::size<1>(), test_defs::get<char>::value<1>());
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc2(test_defs::get<int>::size<2>(), test_defs::get<char>::value<2>());
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<int>::size<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<int>::size<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vc1, 0, test_defs::get<int>::size<1>(), test_defs::get<char>::value<1>());
|
||||
ASSERT_RANGE_VEC_EQ(vc1, test_defs::get<int>::size<1>(), test_defs::get<int>::capacity<1>(), char());
|
||||
ASSERT_RANGE_VEC_EQ(vc2, 0, test_defs::get<int>::size<2>(), test_defs::get<char>::value<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vc2, test_defs::get<int>::size<2>(), test_defs::get<int>::capacity<2>(), char());
|
||||
|
||||
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs1(test_defs::get<int>::size<1>(), test_defs::get<const char *>::value<1>());
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs2(test_defs::get<int>::size<2>(), test_defs::get<const char *>::value<2>());
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<int>::size<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<int>::size<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vs1, 0, test_defs::get<int>::size<1>(), test_defs::get<const char *>::value<1>());
|
||||
ASSERT_RANGE_VEC_EQ(vs2, 0, test_defs::get<int>::size<2>(), test_defs::get<const char *>::value<2>());
|
||||
|
||||
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<1>()> vo1(test_defs::get<int>::size<1>(), test_defs::get<TestStruct>::value<1>());
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<2>()> vo2(test_defs::get<int>::size<2>(), test_defs::get<TestStruct>::value<2>());
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<int>::size<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<int>::size<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vo1, 0, test_defs::get<int>::size<1>(), test_defs::get<TestStruct>::value<1>());
|
||||
ASSERT_RANGE_VEC_EQ(vo1, test_defs::get<int>::size<1>(), test_defs::get<int>::capacity<1>(), TestStruct {});
|
||||
ASSERT_RANGE_VEC_EQ(vo2, 0, test_defs::get<int>::size<2>(), test_defs::get<TestStruct>::value<2>());
|
||||
ASSERT_RANGE_VEC_EQ(vo2, test_defs::get<int>::size<2>(), test_defs::get<int>::capacity<2>(), TestStruct {});
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(const value_type (&array)[N])", []() constexpr {
|
||||
|
||||
cc::const_vector vi1(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector vi2(test_defs::get<int>::arr<2>);
|
||||
/*cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4(test_defs::get<int>::arr<2>);*/
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vi1, test_defs::get<int>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi2, test_defs::get<int>::arr<2>);
|
||||
/*ASSERT(vi3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi3.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi4.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vi3, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::capacity<1>(), int());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vi4, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::capacity<2>(), int());*/
|
||||
|
||||
|
||||
cc::const_vector vc1(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc2(test_defs::get<char>::arr<2>);
|
||||
/*cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc3(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc4(test_defs::get<char>::arr<2>);*/
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vc1, test_defs::get<char>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc2, test_defs::get<char>::arr<2>);
|
||||
/*ASSERT(vc3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc3.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc4.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, test_defs::get<char>::arr_len<1>(), test_defs::get<char>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vc3, test_defs::get<char>::arr_len<1>(), test_defs::get<int>::capacity<1>(), char());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, test_defs::get<char>::arr_len<2>(), test_defs::get<char>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vc4, test_defs::get<char>::arr_len<2>(), test_defs::get<int>::capacity<2>(), char());*/
|
||||
|
||||
|
||||
cc::const_vector vs1(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs2(test_defs::get<const char *>::arr<2>);
|
||||
/*cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs3(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs4(test_defs::get<const char *>::arr<2>);*/
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vs1, test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs2, test_defs::get<const char *>::arr<2>);
|
||||
/*ASSERT(vs3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs3.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs4.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, test_defs::get<const char *>::arr_len<1>(), test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, test_defs::get<const char *>::arr_len<2>(), test_defs::get<const char *>::arr<2>);*/
|
||||
|
||||
|
||||
cc::const_vector vo1(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo2(test_defs::get<TestStruct>::arr<2>);
|
||||
/*cc::const_vector<TestStruct, test_defs::get<int>::capacity<1>()> vo3(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<2>()> vo4(test_defs::get<TestStruct>::arr<2>);*/
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vo1, test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo2, test_defs::get<TestStruct>::arr<2>);
|
||||
/*ASSERT(vo3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo3.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo4.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vo3, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<int>::capacity<1>(), TestStruct {});
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<TestStruct>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vo4, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<int>::capacity<2>(), TestStruct {});*/
|
||||
|
||||
return TEST_PASS();
|
||||
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(const value_type (&array)[N2])", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {
|
||||
|
||||
cc::const_vector<T, test_params<"arr", Ctx>::get_arr_len() + 1> v(test_context_params<T, N>::template value<"arr">);
|
||||
|
||||
ASSERT_TYPE_NUM((v.size() == test_params<"arr", Ctx>::get_arr_len()), T, N);
|
||||
ASSERT_TYPE_NUM_RANGE_VEC_ARR_EQ(v, 0, (test_params<"arr", Ctx>::get_arr_len()), (test_context_params<T, N>::template value<"arr">), T, N);
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS((cc::const_vector<T, test_params<"arr", Ctx>::get_arr_len() - 1>(test_context_params<T, N>::template value<"arr">)), std::invalid_argument, T, N);
|
||||
ASSERT((v1.capacity() == get_test_param<ctx, "capacity">()), ctx);
|
||||
ASSERT((v1.size() == get_test_param<ctx, "capacity">()), ctx);
|
||||
ASSERT(all_equal_to(v1, get_test_param<ctx, "value">()), ctx);
|
||||
ASSERT((v2.capacity() == get_test_param<ctx, "capacity">()), ctx);
|
||||
ASSERT((v2.size() == get_test_param<ctx, "capacity">() / 2), ctx);
|
||||
ASSERT(all_equal_to(v2, get_test_param<ctx, "value">()), ctx);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
}), 2, int , char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(const value_type (&array)[])", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() constexpr {
|
||||
|
||||
std::remove_cvref_t<decltype(get_test_param<ctx, "arr">())> arr = {};
|
||||
std::copy(std::begin(get_test_param<ctx, "arr">()), std::end(get_test_param<ctx, "arr">()), std::begin(arr));
|
||||
|
||||
cc::const_vector v1(arr);
|
||||
cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">()) + 1> v2(arr);
|
||||
|
||||
ASSERT((v1.capacity() == c_arr_len(arr)), ctx);
|
||||
ASSERT(std::ranges::equal(v1, arr), ctx); // also checks size
|
||||
ASSERT((v2.capacity() == c_arr_len(arr) + 1), ctx);
|
||||
ASSERT(std::ranges::equal(v2, arr), ctx);
|
||||
|
||||
ASSERT(std::ranges::equal(arr, get_test_param<ctx, "arr">()));
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int , char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(std::initializer_list<value_type> list)", []() constexpr {
|
||||
|
||||
auto vi1 = CREATE_FROM_IL(cc::const_vector, test_defs::get<int>::i_list<1>, test_defs::get<int>::il_len<1>());
|
||||
auto vi2 = CREATE_FROM_IL(cc::const_vector, test_defs::get<int>::i_list<2>, test_defs::get<int>::il_len<2>());
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3(test_defs::get<int>::i_list<1>);
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4(test_defs::get<int>::i_list<2>);
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() constexpr {
|
||||
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<int, test_defs::get<int>::il_len<1>() - 1>), test_defs::get<int>::i_list<1>, test_defs::get<int>::il_len<1>())), std::invalid_argument);
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<int, test_defs::get<int>::il_len<2>() - 1>), test_defs::get<int>::i_list<2>, test_defs::get<int>::il_len<2>())), std::invalid_argument);
|
||||
auto v1 = CREATE_FROM_IL(cc::const_vector, (get_test_param<ctx, "ilist">()), (get_test_param<ctx, "ilist">().size()));
|
||||
auto v2 = CREATE_FROM_IL((cc::const_vector<T, get_test_param<ctx, "ilist">().size() + 1>), (get_test_param<ctx, "ilist">()), (get_test_param<ctx, "ilist">().size()));
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vi1, test_defs::get<int>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi2, test_defs::get<int>::i_list<2>);
|
||||
ASSERT(vi3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi3.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi4.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::i_list<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vi3, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::capacity<1>(), int());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::i_list<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vi4, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::capacity<2>(), int());
|
||||
ASSERT_THROWS(CREATE_FROM_IL(cc::const_vector, (get_test_param<ctx, "ilist">()), (get_test_param<ctx, "ilist">().size())), std::invalid_argument, ctx);
|
||||
|
||||
ASSERT((v1.capacity() == get_test_param<ctx, "ilist">().size()), ctx);
|
||||
ASSERT((v1.size() == get_test_param<ctx, "ilist">().size()), ctx);
|
||||
ASSERT(std::ranges::equal(v1, get_test_param<ctx, "ilist">()), ctx);
|
||||
ASSERT((v2.capacity() == get_test_param<ctx, "ilist">().size() + 1), ctx);
|
||||
ASSERT((v2.size() == get_test_param<ctx, "ilist">().size()), ctx);
|
||||
ASSERT(std::ranges::equal(v2, get_test_param<ctx, "ilist">()), ctx);
|
||||
|
||||
auto vc1 = CREATE_FROM_IL(cc::const_vector, test_defs::get<char>::i_list<1>, test_defs::get<char>::il_len<1>());
|
||||
auto vc2 = CREATE_FROM_IL(cc::const_vector, test_defs::get<char>::i_list<2>, test_defs::get<char>::il_len<2>());
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc3(test_defs::get<char>::i_list<1>);
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc4(test_defs::get<char>::i_list<2>);
|
||||
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<char, test_defs::get<char>::il_len<1>() - 1>), test_defs::get<char>::i_list<1>, test_defs::get<char>::il_len<1>())), std::invalid_argument);
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<char, test_defs::get<char>::il_len<2>() - 1>), test_defs::get<char>::i_list<2>, test_defs::get<char>::il_len<2>())), std::invalid_argument);
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vc1, test_defs::get<char>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc2, test_defs::get<char>::i_list<2>);
|
||||
ASSERT(vc3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc3.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc4.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, test_defs::get<char>::arr_len<1>(), test_defs::get<char>::i_list<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vc3, test_defs::get<char>::arr_len<1>(), test_defs::get<int>::capacity<1>(), char());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, test_defs::get<char>::arr_len<2>(), test_defs::get<char>::i_list<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vc4, test_defs::get<char>::arr_len<2>(), test_defs::get<int>::capacity<2>(), char());
|
||||
|
||||
|
||||
auto vs1 = CREATE_FROM_IL(cc::const_vector, test_defs::get<const char*>::i_list<1>, test_defs::get<const char*>::il_len<1>());
|
||||
auto vs2 = CREATE_FROM_IL(cc::const_vector, test_defs::get<const char*>::i_list<2>, test_defs::get<const char*>::il_len<2>());
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs3(test_defs::get<const char *>::i_list<1>);
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs4(test_defs::get<const char *>::i_list<2>);
|
||||
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<const char*, test_defs::get<const char*>::il_len<1>() - 1>), test_defs::get<const char*>::i_list<1>, test_defs::get<const char*>::il_len<1>())), std::invalid_argument);
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<const char*, test_defs::get<const char*>::il_len<2>() - 1>), test_defs::get<const char*>::i_list<2>, test_defs::get<const char*>::il_len<2>())), std::invalid_argument);
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vs1, test_defs::get<const char *>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs2, test_defs::get<const char *>::i_list<2>);
|
||||
ASSERT(vs3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs3.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs4.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, test_defs::get<const char *>::arr_len<1>(), test_defs::get<const char *>::i_list<1>);
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, test_defs::get<const char *>::arr_len<2>(), test_defs::get<const char *>::i_list<2>);
|
||||
|
||||
|
||||
auto vo1 = CREATE_FROM_IL(cc::const_vector, test_defs::get<TestStruct>::i_list<1>, test_defs::get<TestStruct>::il_len<1>());
|
||||
auto vo2 = CREATE_FROM_IL(cc::const_vector, test_defs::get<TestStruct>::i_list<2>, test_defs::get<TestStruct>::il_len<2>());
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<1>()> vo3(test_defs::get<TestStruct>::i_list<1>);
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<2>()> vo4(test_defs::get<TestStruct>::i_list<2>);
|
||||
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<1>() - 1>), test_defs::get<TestStruct>::i_list<1>, test_defs::get<TestStruct>::il_len<1>())), std::invalid_argument);
|
||||
ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<2>() - 1>), test_defs::get<TestStruct>::i_list<2>, test_defs::get<TestStruct>::il_len<2>())), std::invalid_argument);
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vo1, test_defs::get<TestStruct>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo2, test_defs::get<TestStruct>::i_list<2>);
|
||||
ASSERT(vo3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo3.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo4.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<TestStruct>::i_list<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vo3, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<int>::capacity<1>(), TestStruct {});
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<TestStruct>::i_list<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vo4, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<int>::capacity<2>(), TestStruct {});
|
||||
return TEST_PASS();
|
||||
}), 2, int , char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(InputIt first, InputIt last)", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi1(std::begin(test_defs::get<int>::arr<1>), std::end(test_defs::get<int>::arr<1>));
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi2(std::begin(test_defs::get<int>::arr<2>), std::end(test_defs::get<int>::arr<2>));
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3(std::begin(test_defs::get<int>::arr<1>), std::end(test_defs::get<int>::arr<1>));
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4(std::begin(test_defs::get<int>::arr<2>), std::end(test_defs::get<int>::arr<2>));
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() constexpr {
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi1, 0, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vi1, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::capacity<1>(), int());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi2, 0, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vi2, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::capacity<2>(), int());
|
||||
ASSERT(vi3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi3.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi4.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi3, 0, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vi3, test_defs::get<int>::arr_len<1>(), test_defs::get<int>::capacity<1>(), int());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vi4, 0, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vi4, test_defs::get<int>::arr_len<2>(), test_defs::get<int>::capacity<2>(), int());
|
||||
std::vector container = get_test_param<ctx, "ilist">();
|
||||
|
||||
cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">())> v1(std::begin(get_test_param<ctx, "arr">()), std::end(get_test_param<ctx, "arr">()));
|
||||
cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">()) + 1> v2(std::begin(get_test_param<ctx, "arr">()), std::end(get_test_param<ctx, "arr">()));
|
||||
cc::const_vector<T, get_test_param<ctx, "ilist">().size()> v3(container.begin(), container.end());
|
||||
cc::const_vector<T, get_test_param<ctx, "ilist">().size() + 1> v4(container.begin(), container.end());
|
||||
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc1(std::begin(test_defs::get<char>::arr<1>), std::end(test_defs::get<char>::arr<1>));
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc2(std::begin(test_defs::get<char>::arr<2>), std::end(test_defs::get<char>::arr<2>));
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc3(std::begin(test_defs::get<char>::arr<1>), std::end(test_defs::get<char>::arr<1>));
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc4(std::begin(test_defs::get<char>::arr<2>), std::end(test_defs::get<char>::arr<2>));
|
||||
ASSERT_THROWS((cc::const_vector<T, get_test_param<ctx, "ilist">().size() - 1>(get_test_param<ctx, "ilist">())), std::invalid_argument, ctx);
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc1, 0, test_defs::get<char>::arr_len<1>(), test_defs::get<char>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vc1, test_defs::get<char>::arr_len<1>(), test_defs::get<int>::capacity<1>(), char());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc2, 0, test_defs::get<char>::arr_len<2>(), test_defs::get<char>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vc2, test_defs::get<char>::arr_len<2>(), test_defs::get<int>::capacity<2>(), char());
|
||||
ASSERT(vc3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc3.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc4.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc3, 0, test_defs::get<char>::arr_len<1>(), test_defs::get<char>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vc3, test_defs::get<char>::arr_len<1>(), test_defs::get<int>::capacity<1>(), char());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vc4, 0, test_defs::get<char>::arr_len<2>(), test_defs::get<char>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vc4, test_defs::get<char>::arr_len<2>(), test_defs::get<int>::capacity<2>(), char());
|
||||
ASSERT((v1.capacity() == c_arr_len(get_test_param<ctx, "arr">())), ctx);
|
||||
ASSERT((v1.size() == c_arr_len(get_test_param<ctx, "arr">())), ctx);
|
||||
ASSERT(std::ranges::equal(v1, get_test_param<ctx, "arr">()), ctx);
|
||||
ASSERT((v2.capacity() == c_arr_len(get_test_param<ctx, "arr">()) + 1), ctx);
|
||||
ASSERT((v2.size() == c_arr_len(get_test_param<ctx, "arr">())), ctx);
|
||||
ASSERT(std::ranges::equal(v2, get_test_param<ctx, "arr">()), ctx);
|
||||
|
||||
ASSERT((v3.capacity() == get_test_param<ctx, "ilist">().size()), ctx);
|
||||
ASSERT((v3.size() == container.size()), ctx);
|
||||
ASSERT(std::ranges::equal(v3, container), ctx);
|
||||
ASSERT((v4.capacity() == get_test_param<ctx, "ilist">().size() + 1), ctx);
|
||||
ASSERT((v4.size() == container.size()), ctx);
|
||||
ASSERT(std::ranges::equal(v4, container), ctx);
|
||||
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs1(std::begin(test_defs::get<const char *>::arr<1>), std::end(test_defs::get<const char *>::arr<1>));
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs2(std::begin(test_defs::get<const char *>::arr<2>), std::end(test_defs::get<const char *>::arr<2>));
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs3(std::begin(test_defs::get<const char *>::arr<1>), std::end(test_defs::get<const char *>::arr<1>));
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs4(std::begin(test_defs::get<const char *>::arr<2>), std::end(test_defs::get<const char *>::arr<2>));
|
||||
ASSERT(std::ranges::equal(container, get_test_param<ctx, "ilist">()));
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs1, 0, test_defs::get<const char *>::arr_len<1>(), test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs2, 0, test_defs::get<const char *>::arr_len<2>(), test_defs::get<const char *>::arr<2>);
|
||||
ASSERT(vs3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs3.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs4.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs3, 0, test_defs::get<const char *>::arr_len<1>(), test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, test_defs::get<const char *>::arr_len<2>(), test_defs::get<const char *>::arr<2>);
|
||||
|
||||
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<1>()> vo1(std::begin(test_defs::get<TestStruct>::arr<1>), std::end(test_defs::get<TestStruct>::arr<1>));
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<2>()> vo2(std::begin(test_defs::get<TestStruct>::arr<2>), std::end(test_defs::get<TestStruct>::arr<2>));
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<1>()> vo3(std::begin(test_defs::get<TestStruct>::arr<1>), std::end(test_defs::get<TestStruct>::arr<1>));
|
||||
cc::const_vector<TestStruct, test_defs::get<int>::capacity<2>()> vo4(std::begin(test_defs::get<TestStruct>::arr<2>), std::end(test_defs::get<TestStruct>::arr<2>));
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo1, 0, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vo1, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<int>::capacity<1>(), TestStruct {});
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo2, 0, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<TestStruct>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vo2, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<int>::capacity<2>(), TestStruct {});
|
||||
ASSERT(vo3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo3.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo4.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo3, 0, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_RANGE_VEC_EQ(vo3, test_defs::get<TestStruct>::arr_len<1>(), test_defs::get<int>::capacity<1>(), TestStruct {});
|
||||
ASSERT_RANGE_VEC_ARR_EQ(vo4, 0, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<TestStruct>::arr<2>);
|
||||
ASSERT_RANGE_VEC_EQ(vo4, test_defs::get<TestStruct>::arr_len<2>(), test_defs::get<int>::capacity<2>(), TestStruct {});
|
||||
return TEST_PASS();
|
||||
}), 2, int , char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(const const_vector& other)", []() constexpr {
|
||||
|
||||
cc::const_vector vi1(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector vi2(test_defs::get<int>::arr<2>);
|
||||
cc::const_vector vi1c(vi1);
|
||||
cc::const_vector vi2c(vi2);
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3(vi1);
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4(vi2);
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() {
|
||||
|
||||
ASSERT(vi1c.capacity() == vi1.capacity());
|
||||
ASSERT(vi2c.capacity() == vi2.capacity());
|
||||
ASSERT(vi1c.size() == vi1.size());
|
||||
ASSERT(vi2c.size() == vi2.size());
|
||||
ASSERT_VEC_EQ(vi1c, vi1);
|
||||
ASSERT_VEC_EQ(vi2c, vi2);
|
||||
ASSERT(vi3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi3.size() == vi1.size());
|
||||
ASSERT(vi4.size() == vi2.size());
|
||||
ASSERT_VEC_EQ(vi3, vi1);
|
||||
ASSERT_VEC_EQ(vi4, vi2);
|
||||
cc::const_vector original(get_test_param<ctx, "arr">());
|
||||
|
||||
cc::const_vector v1(original);
|
||||
cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">()) + 1> v2(original);
|
||||
|
||||
cc::const_vector vc1(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc2(test_defs::get<char>::arr<2>);
|
||||
cc::const_vector vc1c(vc1);
|
||||
cc::const_vector vc2c(vc2);
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<1>()> vc3(vc1);
|
||||
cc::const_vector<char, test_defs::get<int>::capacity<2>()> vc4(vc2);
|
||||
ASSERT_THROWS((cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">()) - 1>(original)), std::invalid_argument, ctx);
|
||||
|
||||
ASSERT(vc1c.capacity() == vc1.capacity());
|
||||
ASSERT(vc2c.capacity() == vc2.capacity());
|
||||
ASSERT(vc1c.size() == vc1.size());
|
||||
ASSERT(vc2c.size() == vc2.size());
|
||||
ASSERT_VEC_EQ(vc1c, vc1);
|
||||
ASSERT_VEC_EQ(vc2c, vc2);
|
||||
ASSERT(vc3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vc4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vc3.size() == vc1.size());
|
||||
ASSERT(vc4.size() == vc2.size());
|
||||
ASSERT_VEC_EQ(vc3, vc1);
|
||||
ASSERT_VEC_EQ(vc4, vc2);
|
||||
ASSERT(std::ranges::equal(v1, original), ctx);
|
||||
ASSERT(std::ranges::equal(v2, original), ctx);
|
||||
|
||||
ASSERT(std::ranges::equal(original, get_test_param<ctx, "arr">()), ctx);
|
||||
|
||||
cc::const_vector vs1(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs2(test_defs::get<const char *>::arr<2>);
|
||||
cc::const_vector vs1c(vs1);
|
||||
cc::const_vector vs2c(vs2);
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<1>()> vs3(vs1);
|
||||
cc::const_vector<const char *, test_defs::get<int>::capacity<2>()> vs4(vs2);
|
||||
|
||||
ASSERT(vs1c.capacity() == vs1.capacity());
|
||||
ASSERT(vs2c.capacity() == vs2.capacity());
|
||||
ASSERT(vs1c.size() == vs1.size());
|
||||
ASSERT(vs2c.size() == vs2.size());
|
||||
ASSERT_VEC_EQ(vs1c, vs1);
|
||||
ASSERT_VEC_EQ(vs2c, vs2);
|
||||
ASSERT(vs3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vs4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vs3.size() == vs1.size());
|
||||
ASSERT(vs4.size() == vs2.size());
|
||||
ASSERT_VEC_EQ(vs3, vs1);
|
||||
ASSERT_VEC_EQ(vs4, vs2);
|
||||
|
||||
|
||||
cc::const_vector vo1(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo2(test_defs::get<TestStruct>::arr<2>);
|
||||
cc::const_vector vo1c(vo1);
|
||||
cc::const_vector vo2c(vo2);
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3(vo1);
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4(vo2);
|
||||
|
||||
ASSERT(vo1c.capacity() == vo1.capacity());
|
||||
ASSERT(vo2c.capacity() == vo2.capacity());
|
||||
ASSERT(vo1c.size() == vo1.size());
|
||||
ASSERT(vo2c.size() == vo2.size());
|
||||
ASSERT_VEC_EQ(vo1c, vo1);
|
||||
ASSERT_VEC_EQ(vo2c, vo2);
|
||||
ASSERT(vo3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vo4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vo3.size() == vo1.size());
|
||||
ASSERT(vo4.size() == vo2.size());
|
||||
ASSERT_VEC_EQ(vo3, vo1);
|
||||
ASSERT_VEC_EQ(vo4, vo2);
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(const_vector&& other)", []() constexpr {
|
||||
|
||||
cc::const_vector vi11(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector vi21(test_defs::get<int>::arr<2>);
|
||||
cc::const_vector vi12(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector vi22(test_defs::get<int>::arr<2>);
|
||||
cc::const_vector vi13(test_defs::get<int>::arr<1>);
|
||||
cc::const_vector vi23(test_defs::get<int>::arr<2>);
|
||||
cc::const_vector vi1(force_move(vi11));
|
||||
cc::const_vector vi2(force_move(vi21));
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3(force_move(vi12));
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4(force_move(vi22));
|
||||
|
||||
ASSERT_THROWS((cc::const_vector<int, (test_defs::get<int>::arr_len<1>() - 1)>(force_move(vi13))), std::invalid_argument);
|
||||
ASSERT_THROWS((cc::const_vector<int, (test_defs::get<int>::arr_len<2>() - 1)>(force_move(vi23))), std::invalid_argument);
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename ctx>() {
|
||||
|
||||
ASSERT(vi1.capacity() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.capacity() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT(vi1.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vi1, test_defs::get<int>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi2, test_defs::get<int>::arr<2>);
|
||||
ASSERT(vi3.capacity() == test_defs::get<int>::capacity<1>());
|
||||
ASSERT(vi4.capacity() == test_defs::get<int>::capacity<2>());
|
||||
ASSERT(vi3.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi4.size() == test_defs::get<int>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vi3, test_defs::get<int>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi4, test_defs::get<int>::arr<2>);
|
||||
cc::const_vector original1(get_test_param<ctx, "arr">());
|
||||
cc::const_vector original2(get_test_param<ctx, "arr">());
|
||||
cc::const_vector original3(get_test_param<ctx, "arr">());
|
||||
|
||||
cc::const_vector vc11(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc21(test_defs::get<char>::arr<2>);
|
||||
cc::const_vector vc12(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc22(test_defs::get<char>::arr<2>);
|
||||
cc::const_vector vc13(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc23(test_defs::get<char>::arr<2>);
|
||||
cc::const_vector vc1(force_move(vc11));
|
||||
cc::const_vector vc2(force_move(vc21));
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc3(force_move(vc12));
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc4(force_move(vc22));
|
||||
decltype(original1) v1(force_move(original1));
|
||||
cc::const_vector<T, get_test_param<ctx, "capacity">()> v2(force_move(original2));
|
||||
|
||||
ASSERT_THROWS((cc::const_vector<char, (test_defs::get<char>::arr_len<1>() - 1)>(force_move(vc13))), std::invalid_argument);
|
||||
ASSERT_THROWS((cc::const_vector<char, (test_defs::get<char>::arr_len<2>() - 1)>(force_move(vc23))), std::invalid_argument);
|
||||
ASSERT_THROWS((cc::const_vector<T, c_arr_len(get_test_param<ctx, "arr">()) - 1>(force_move(original3))), std::invalid_argument, ctx);
|
||||
|
||||
ASSERT(vc1.capacity() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.capacity() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT(vc1.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vc1, test_defs::get<char>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc2, test_defs::get<char>::arr<2>);
|
||||
ASSERT(vc3.capacity() == test_defs::get<char>::capacity<1>());
|
||||
ASSERT(vc4.capacity() == test_defs::get<char>::capacity<2>());
|
||||
ASSERT(vc3.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc4.size() == test_defs::get<char>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vc3, test_defs::get<char>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc4, test_defs::get<char>::arr<2>);
|
||||
ASSERT(std::ranges::equal(v1, get_test_param<ctx, "arr">()), ctx);
|
||||
ASSERT(std::ranges::equal(v2, get_test_param<ctx, "arr">()), ctx);
|
||||
|
||||
cc::const_vector vs11(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs21(test_defs::get<const char *>::arr<2>);
|
||||
cc::const_vector vs12(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs22(test_defs::get<const char *>::arr<2>);
|
||||
cc::const_vector vs13(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs23(test_defs::get<const char *>::arr<2>);
|
||||
cc::const_vector vs1(force_move(vs11));
|
||||
cc::const_vector vs2(force_move(vs21));
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<1>()> vs3(force_move(vs12));
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<2>()> vs4(force_move(vs22));
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
ASSERT_THROWS((cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<1>() - 1)>(force_move(vs13))), std::invalid_argument);
|
||||
ASSERT_THROWS((cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<2>() - 1)>(force_move(vs23))), std::invalid_argument);
|
||||
|
||||
ASSERT(vs1.capacity() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.capacity() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT(vs1.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vs1, test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs2, test_defs::get<const char *>::arr<2>);
|
||||
ASSERT(vs3.capacity() == test_defs::get<const char *>::capacity<1>());
|
||||
ASSERT(vs4.capacity() == test_defs::get<const char *>::capacity<2>());
|
||||
ASSERT(vs3.size() == test_defs::get<const char *>::arr_len<1>());
|
||||
ASSERT(vs4.size() == test_defs::get<const char *>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vs3, test_defs::get<const char *>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs4, test_defs::get<const char *>::arr<2>);
|
||||
|
||||
cc::const_vector vo11(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo21(test_defs::get<TestStruct>::arr<2>);
|
||||
cc::const_vector vo12(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo22(test_defs::get<TestStruct>::arr<2>);
|
||||
cc::const_vector vo13(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo23(test_defs::get<TestStruct>::arr<2>);
|
||||
cc::const_vector vo1(force_move(vo11));
|
||||
cc::const_vector vo2(force_move(vo21));
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3(force_move(vo12));
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4(force_move(vo22));
|
||||
|
||||
ASSERT_THROWS((cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<1>() - 1)>(force_move(vo13))), std::invalid_argument);
|
||||
ASSERT_THROWS((cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<2>() - 1)>(force_move(vo23))), std::invalid_argument);
|
||||
|
||||
ASSERT(vo1.capacity() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.capacity() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vo1, test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo2, test_defs::get<TestStruct>::arr<2>);
|
||||
ASSERT(vo3.capacity() == test_defs::get<TestStruct>::capacity<1>());
|
||||
ASSERT(vo4.capacity() == test_defs::get<TestStruct>::capacity<2>());
|
||||
ASSERT(vo3.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo4.size() == test_defs::get<TestStruct>::arr_len<2>());
|
||||
ASSERT_VEC_ARR_EQ(vo3, test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo4, test_defs::get<TestStruct>::arr<2>);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL);
|
||||
|
||||
int main() {
|
||||
return tests.run();
|
||||
}
|
||||
|
||||
#pragma clang diagnostic pop
|
||||
}
|
||||
Loading…
Reference in New Issue