Compare commits
7 Commits
ddaed337cf
...
953ad58939
| Author | SHA1 | Date |
|---|---|---|
 cyborg1811m
|
953ad58939 | |
|
cyborg1811m
|
1c91e3ec75 | |
|
cyborg1811m
|
70e2108501 | |
|
cyborg1811m
|
5ed9fd9146 | |
|
cyborg1811m
|
9f307442dc | |
|
cyborg1811m
|
c8144b041c | |
|
cyborg1811m
|
1b96fd982e |
|
|
@ -46,7 +46,7 @@ namespace cc {
|
|||
|
||||
constexpr explicit const_vector(const value_type (&array)[N]) noexcept;
|
||||
template <std::size_t N2>
|
||||
constexpr explicit const_vector(const value_type (&array)[N2]) noexcept;
|
||||
constexpr explicit const_vector(const value_type (&array)[N2]);
|
||||
|
||||
constexpr const_vector(std::initializer_list<value_type> values);
|
||||
|
||||
|
|
@ -68,7 +68,7 @@ namespace cc {
|
|||
constexpr const_vector<T, N>& operator=(const_vector&& other) noexcept;
|
||||
template <std::size_t N2>
|
||||
constexpr const_vector<T, N>& operator=(const_vector<value_type, N2>&& other);
|
||||
//constexpr const_vector<T, N>& operator=(const value_type (&array)[N]) noexcept; // not needed as functionally equivalent to templated overload
|
||||
//constexpr const_vector<T, N>& operator=(const value_type (&array)[N]) noexcept; // not needed as functionally equivalent to templated overload, could be noexcept though
|
||||
template <std::size_t N2>
|
||||
constexpr const_vector<T, N>& operator=(const value_type (&array)[N2]);
|
||||
constexpr const_vector<T, N>& operator=(std::initializer_list<value_type> values);
|
||||
|
|
@ -213,7 +213,16 @@ namespace cc {
|
|||
constexpr const_vector<T, N>::const_vector(const value_type (&array)[N]) noexcept
|
||||
: _size(N)
|
||||
{
|
||||
std::move(std::begin(array), std::end(array), _arr);
|
||||
std::copy(std::begin(array), std::end(array), _arr);
|
||||
}
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
template<std::size_t N2>
|
||||
constexpr const_vector<T, N>::const_vector(const value_type (&array)[N2])
|
||||
: _size(N2)
|
||||
{
|
||||
if (N < N2) throw std::invalid_argument("Size of array has to be smaller or equal to the capacity: " + std::to_string(N2) + ">=" + std::to_string(N));
|
||||
std::copy(std::begin(array), std::end(array), _arr);
|
||||
}
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
#define _LOCATION " (at " _EXPAND_MACRO(__FILE__) ":" _EXPAND_MACRO(__LINE__) ")"
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
consteval std::size_t c_array_len(T (&arr)[N]) { return N; }
|
||||
consteval std::size_t c_arr_len(T (&arr)[N]) { return N; }
|
||||
|
||||
#define ADD_TYPE_HINT(type) template <> constexpr const char* const to_type_hint_str::value<type> = #type
|
||||
|
||||
|
|
@ -26,6 +26,7 @@ consteval std::size_t c_array_len(T (&arr)[N]) { return N; }
|
|||
#define TEST_PASS() ret_val_s { "", ReturnCode::PASSED, nullptr }
|
||||
#define TEST_PASS_MSG(msg) ret_val_s { "", ReturnCode::PASSED, msg }
|
||||
#define TEST_SKIP() ret_val_s { "", ReturnCode::SKIPPED, nullptr}
|
||||
#define TEST_SKIP_MSG(msg) ret_val_s { "", ReturnCode::SKIPPED, msg}
|
||||
|
||||
#define TEST_FAIL_TYPE(msg, type_hint) ret_val_s { "", ReturnCode::FAILED, msg, to_type_hint_str::value<type_hint> }
|
||||
#define TEST_PASS_TYPE(type_hint) ret_val_s { "", ReturnCode::PASSED, nullptr, to_type_hint_str::value<type_hint> }
|
||||
|
|
@ -153,6 +154,17 @@ struct ret_val {
|
|||
constexpr inline const ret_val_s& operator[](std::size_t i) const { return vals[i]; }
|
||||
};
|
||||
|
||||
template<typename Ctx>
|
||||
concept ctx_has_type_num = requires {
|
||||
typename Ctx::type;
|
||||
{ Ctx::nr } -> std::convertible_to<std::size_t>;
|
||||
};
|
||||
|
||||
template<typename Ctx>
|
||||
concept ctx_has_type = requires {
|
||||
typename Ctx::type;
|
||||
};
|
||||
|
||||
struct empty_param {};
|
||||
|
||||
struct test_common_params {
|
||||
|
|
@ -169,7 +181,24 @@ struct test_context_params {
|
|||
constexpr static auto value = empty_param{};
|
||||
};
|
||||
|
||||
template<tstring Name, typename Ctx = void>
|
||||
template<tstring name>
|
||||
constexpr auto& get_test_param() {
|
||||
return test_common_params::value<name>;
|
||||
}
|
||||
|
||||
template<typename Ctx, tstring name>
|
||||
requires requires { typename Ctx::type; { Ctx::nr } -> std::convertible_to<std::size_t>; }
|
||||
constexpr auto& get_test_param() {
|
||||
return test_context_params<typename Ctx::type, Ctx::nr>::template value<name>;
|
||||
}
|
||||
|
||||
template<typename Ctx, tstring name>
|
||||
requires requires { typename Ctx::type; } && (!requires { Ctx::nr; })
|
||||
constexpr auto& get_test_param() {
|
||||
return test_context_params<typename Ctx::type, Ctx::nr>::template value<name>;
|
||||
}
|
||||
|
||||
/*template<tstring Name, typename Ctx = void>
|
||||
struct test_params {
|
||||
constexpr static auto get() {
|
||||
if constexpr (requires { typename Ctx::type; }) {
|
||||
|
|
@ -182,7 +211,19 @@ struct test_params {
|
|||
return test_common_params::template value<Name>;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
constexpr static auto get_arr_len() {
|
||||
if constexpr (requires { typename Ctx::type; }) {
|
||||
if constexpr (requires { { Ctx::nr } -> std::convertible_to<std::size_t>; }) {
|
||||
return c_arr_len(test_context_params<typename Ctx::type, Ctx::nr>::template value<Name>);
|
||||
} else {
|
||||
return c_arr_len(test_context_params<typename Ctx::type>::template value<Name>);
|
||||
}
|
||||
} else {
|
||||
return c_arr_len(test_common_params::template value<Name>);
|
||||
}
|
||||
}
|
||||
};*/
|
||||
|
||||
#define CONTEXT_PARAM(type, name, ...) template<> template<> constexpr type test_context_params<__VA_ARGS__>::value< #name >
|
||||
#define CONTEXT_PARAM_ARR(type, name, ...) template<> template<> constexpr type test_context_params<__VA_ARGS__>::value< #name >[]
|
||||
|
|
|
|||
|
|
@ -7,3 +7,13 @@ add_executable(test_const_vector_constructor const_vector_constructor.test.cpp
|
|||
test_params.h)
|
||||
target_link_libraries(test_const_vector_constructor const_container test_common)
|
||||
add_test(NAME "const_vector constructor" COMMAND test_const_vector_constructor)
|
||||
|
||||
add_executable(test_const_vector_assignment const_vector_assignment.test.cpp
|
||||
test_params.h)
|
||||
target_link_libraries(test_const_vector_assignment const_container test_common)
|
||||
add_test(NAME "const_vector assignment" COMMAND test_const_vector_assignment)
|
||||
|
||||
add_executable(test_const_vector_data_access const_vector_data_access.test.cpp
|
||||
test_params.h)
|
||||
target_link_libraries(test_const_vector_data_access const_container test_common)
|
||||
add_test(NAME "const_vector data access" COMMAND test_const_vector_data_access)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,179 @@
|
|||
#include <const_vector.hpp>
|
||||
|
||||
#include <test.hpp>
|
||||
#include "test_params.h"
|
||||
|
||||
constexpr test_suite tests = define_tests("Assignment")
|
||||
("const_vector::operator=(const const_vector& other)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {
|
||||
|
||||
cc::const_vector original(Ctx::template value<"arr">);
|
||||
|
||||
decltype(original) v1;
|
||||
cc::const_vector<T, get_test_param<"capacity">()> v2;
|
||||
cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;
|
||||
|
||||
v1 = original;
|
||||
v2 = original;
|
||||
ASSERT_TYPE_NUM_THROWS((too_small = original), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(original, Ctx::template value<"arr">), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::operator=(const_vector&& other)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {
|
||||
|
||||
cc::const_vector original1(Ctx::template value<"arr">);
|
||||
cc::const_vector original2(Ctx::template value<"arr">);
|
||||
cc::const_vector original3(Ctx::template value<"arr">);
|
||||
|
||||
decltype(original1) v1;
|
||||
cc::const_vector<T, test_params<"capacity", Ctx>> v2;
|
||||
cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;
|
||||
|
||||
v1 = force_move(original1);
|
||||
v2 = force_move(original2);
|
||||
ASSERT_TYPE_NUM_THROWS((too_small = force_move(original3)), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::operator=(const value_type (&array)[])", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {
|
||||
|
||||
std::remove_cvref_t<decltype(Ctx::template value<"arr">)> arr = {};
|
||||
std::copy(std::begin(Ctx::template value<"arr">), std::end(Ctx::template value<"arr">), std::begin(arr));
|
||||
|
||||
cc::const_vector<T, c_arr_len(arr)> v1;
|
||||
cc::const_vector<T, test_params<"capacity", Ctx>> v2;
|
||||
cc::const_vector<T, c_arr_len(Ctx::template value<"arr">) - 1> too_small;
|
||||
|
||||
v1 = arr;
|
||||
v2 = arr;
|
||||
ASSERT_TYPE_NUM_THROWS((too_small = arr), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v1, Ctx::template value<"arr">), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v2, Ctx::template value<"arr">), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(arr, Ctx::template value<"arr">), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::operator=(std::initializer_list<value_type> values)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() {
|
||||
|
||||
cc::const_vector<T, test_params<"ilist", Ctx>.size()> v1;
|
||||
cc::const_vector<T, test_params<"capacity", Ctx>> v2;
|
||||
cc::const_vector<T, test_params<"ilist", Ctx>.size() - 1> too_small;
|
||||
|
||||
v1 = test_params<"ilist", Ctx>;
|
||||
v2 = test_params<"ilist", Ctx>;
|
||||
ASSERT_TYPE_NUM_THROWS((too_small = test_params<"ilist", Ctx>), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v1, test_params<"ilist", Ctx>), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::equal(v2, test_params<"ilist", Ctx>), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
|
||||
("const_vector::assign(size_type count, const value_type& value)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {
|
||||
|
||||
std::remove_cvref_t<decltype(test_params<"value", Ctx>)> value = test_params<"value", Ctx>;
|
||||
|
||||
cc::const_vector v1(test_params<"arr", Ctx>);
|
||||
cc::const_vector v2(test_params<"arr", Ctx>);
|
||||
|
||||
auto count1 = v1.size();
|
||||
auto count2 = v2.size() / 2;
|
||||
|
||||
v1.assign(count1, value);
|
||||
v2.assign(count2, value);
|
||||
|
||||
ASSERT_TYPE_NUM(v1.size() == count1, T, N);
|
||||
ASSERT_TYPE_NUM(v2.size() == count2, T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::all_of(v1, [value](auto&& e) { return e == value; }), T, N);
|
||||
ASSERT_TYPE_NUM(std::ranges::all_of(v1, [value](auto&& e) { return e == value; }), T, N);
|
||||
|
||||
ASSERT_TYPE_NUM((value == test_params<"value", Ctx>), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char*, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
/*("const_vector::assign(InputIt first, InputIt last)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t n, typename params>() constexpr {
|
||||
constexpr std::size_t N = n+1;
|
||||
cc::const_vector<T, test_defs::get<T>::template arr_len<N>()> v1;
|
||||
cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v2;
|
||||
cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v3;
|
||||
cc::const_vector<T, test_defs::get<T>::template arr_len<N>() - 1> v4;
|
||||
|
||||
std::vector<T> container = test_defs::get<T>::template i_list<N>;
|
||||
|
||||
v1.assign(std::begin(test_defs::get<T>::template arr<N>), std::end(test_defs::get<T>::template arr<N>));
|
||||
v2.assign(container.begin(), container.end());
|
||||
v3.assign(container.begin(), std::next(container.begin(), test_defs::get<T>::template il_len<N>() / 2));
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS(
|
||||
(v4.assign(std::begin(test_defs::get<T>::template arr<N>),
|
||||
std::end(test_defs::get<T>::template arr<N>))), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, test_defs::get<T>::template arr<N>, T, N);
|
||||
ASSERT_TYPE_NUM(v1.size() == test_defs::get<T>::template arr_len<N>(), T, N);
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v2, container, T, N);
|
||||
ASSERT_TYPE_NUM(v2.size() == container.size(), T, N);
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v3, container, T, N);
|
||||
ASSERT_TYPE_NUM(v3.size() == container.size() / 2, T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 3, int, char, const char *, TestStruct);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::assign(std::initializer_list<value_type> values)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {
|
||||
|
||||
cc::const_vector<T, (test_params<"ilist", Ctx>).size()> v1;
|
||||
cc::const_vector<T, (test_params<"ilist", Ctx>).size() - 1> v2;
|
||||
|
||||
v1.assign(test_params<"ilist", Ctx>);
|
||||
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, (test_params<"ilist", Ctx>), T, N);
|
||||
ASSERT_TYPE_NUM((v1.size() == test_params<"ilist", Ctx>.size()), T, N);
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS(v2.assign(test_params<"ilist", Ctx>), std::invalid_argument, T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)*/;
|
||||
|
||||
int main() {
|
||||
return tests.run();
|
||||
}
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
#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("Tests")
|
||||
constexpr test_suite tests = define_tests("Constructors")
|
||||
("const_vector()", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi1;
|
||||
|
|
@ -265,6 +265,23 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
|
||||
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);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector(std::initializer_list<value_type> list)", []() constexpr {
|
||||
|
||||
|
|
@ -652,575 +669,7 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
ASSERT_VEC_ARR_EQ(vo4, test_defs::get<TestStruct>::arr<2>);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
|
||||
("const_vector::operator=(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>);
|
||||
decltype(vi1) vi1c;
|
||||
decltype(vi2) vi2c;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4;
|
||||
cc::const_vector<int, (test_defs::get<int>::arr_len<1>() - 1)> too_small_vi1c;
|
||||
cc::const_vector<int, (test_defs::get<int>::arr_len<2>() - 1)> too_small_vi2c;
|
||||
|
||||
cc::const_vector vc1(test_defs::get<char>::arr<1>);
|
||||
cc::const_vector vc2(test_defs::get<char>::arr<2>);
|
||||
decltype(vc1) vc1c;
|
||||
decltype(vc2) vc2c;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc3;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc4;
|
||||
cc::const_vector<char, (test_defs::get<char>::arr_len<1>() - 1)> too_small_vc1c;
|
||||
cc::const_vector<char, (test_defs::get<char>::arr_len<2>() - 1)> too_small_vc2c;
|
||||
|
||||
cc::const_vector vs1(test_defs::get<const char *>::arr<1>);
|
||||
cc::const_vector vs2(test_defs::get<const char *>::arr<2>);
|
||||
decltype(vs1) vs1c;
|
||||
decltype(vs2) vs2c;
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<1>()> vs3;
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<2>()> vs4;
|
||||
cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<1>() - 1)> too_small_vs1c;
|
||||
cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<2>() - 1)> too_small_vs2c;
|
||||
|
||||
cc::const_vector vo1(test_defs::get<TestStruct>::arr<1>);
|
||||
cc::const_vector vo2(test_defs::get<TestStruct>::arr<2>);
|
||||
decltype(vo1) vo1c;
|
||||
decltype(vo2) vo2c;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4;
|
||||
cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<1>() - 1)> too_small_vo1c;
|
||||
cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<2>() - 1)> too_small_vo2c;
|
||||
|
||||
vi1c = vi1;
|
||||
vi2c = vi2;
|
||||
vi3 = vi1;
|
||||
vi4 = vi2;
|
||||
|
||||
vi1 = vi1;
|
||||
vi2 = vi2;
|
||||
|
||||
ASSERT_THROWS((too_small_vi1c = vi1), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vi2c = vi2), std::invalid_argument);
|
||||
|
||||
// Due to self assignment
|
||||
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(vi1c.size() == vi1.size());
|
||||
ASSERT(vi2c.size() == vi2.size());
|
||||
ASSERT_VEC_EQ(vi1c, vi1);
|
||||
ASSERT_VEC_EQ(vi2c, vi2);
|
||||
ASSERT(vi3.size() == vi1.size());
|
||||
ASSERT(vi4.size() == vi2.size());
|
||||
ASSERT_VEC_EQ(vi3, vi1);
|
||||
ASSERT_VEC_EQ(vi4, vi2);
|
||||
|
||||
vc1c = vc1;
|
||||
vc2c = vc2;
|
||||
vc3 = vc1;
|
||||
vc4 = vc2;
|
||||
|
||||
vc1 = vc1;
|
||||
vc2 = vc2;
|
||||
|
||||
ASSERT_THROWS((too_small_vc1c = vc1), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vc2c = vc2), std::invalid_argument);
|
||||
|
||||
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(vc1c.size() == vc1.size());
|
||||
ASSERT(vc2c.size() == vc2.size());
|
||||
ASSERT_VEC_EQ(vc1c, vc1);
|
||||
ASSERT_VEC_EQ(vc2c, vc2);
|
||||
ASSERT(vc3.size() == vc1.size());
|
||||
ASSERT(vc4.size() == vc2.size());
|
||||
ASSERT_VEC_EQ(vc3, vc1);
|
||||
ASSERT_VEC_EQ(vc4, vc2);
|
||||
|
||||
vs1c = vs1;
|
||||
vs2c = vs2;
|
||||
vs3 = vs1;
|
||||
vs4 = vs2;
|
||||
|
||||
vs1 = vs1;
|
||||
vs2 = vs2;
|
||||
|
||||
ASSERT_THROWS((too_small_vs1c = vs1), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vs2c = vs2), std::invalid_argument);
|
||||
|
||||
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(vs1c.size() == vs1.size());
|
||||
ASSERT(vs2c.size() == vs2.size());
|
||||
ASSERT_VEC_EQ(vs1c, vs1);
|
||||
ASSERT_VEC_EQ(vs2c, vs2);
|
||||
ASSERT(vs3.size() == vs1.size());
|
||||
ASSERT(vs4.size() == vs2.size());
|
||||
ASSERT_VEC_EQ(vs3, vs1);
|
||||
ASSERT_VEC_EQ(vs4, vs2);
|
||||
|
||||
vo1c = vo1;
|
||||
vo2c = vo2;
|
||||
vo3 = vo1;
|
||||
vo4 = vo2;
|
||||
|
||||
vo1 = vo1;
|
||||
vo2 = vo2;
|
||||
|
||||
ASSERT_THROWS((too_small_vo1c = vo1), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vo2c = vo2), std::invalid_argument);
|
||||
|
||||
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(vo1c.size() == vo1.size());
|
||||
ASSERT(vo2c.size() == vo2.size());
|
||||
ASSERT_VEC_EQ(vo1c, vo1);
|
||||
ASSERT_VEC_EQ(vo2c, vo2);
|
||||
ASSERT(vo3.size() == vo1.size());
|
||||
ASSERT(vo4.size() == vo2.size());
|
||||
ASSERT_VEC_EQ(vo3, vo1);
|
||||
ASSERT_VEC_EQ(vo4, vo2);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::operator=(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>);
|
||||
decltype(vi11) vi1;
|
||||
decltype(vi21) vi2;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4;
|
||||
cc::const_vector<int, (test_defs::get<int>::arr_len<1>() - 1)> too_small_vi1c;
|
||||
cc::const_vector<int, (test_defs::get<int>::arr_len<2>() - 1)> too_small_vi2c;
|
||||
|
||||
|
||||
vi1 = force_move(vi11);
|
||||
vi2 = force_move(vi21);
|
||||
vi3 = force_move(vi12);
|
||||
vi4 = force_move(vi22);
|
||||
|
||||
ASSERT_THROWS((too_small_vi1c = force_move(vi13)), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vi2c = force_move(vi23)), std::invalid_argument);
|
||||
|
||||
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.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 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>);
|
||||
decltype(vc11) vc1;
|
||||
decltype(vc21) vc2;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc3;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc4;
|
||||
cc::const_vector<char, (test_defs::get<char>::arr_len<1>() - 1)> too_small_vc1c;
|
||||
cc::const_vector<char, (test_defs::get<char>::arr_len<2>() - 1)> too_small_vc2c;
|
||||
|
||||
|
||||
vc1 = force_move(vc11);
|
||||
vc2 = force_move(vc21);
|
||||
vc3 = force_move(vc12);
|
||||
vc4 = force_move(vc22);
|
||||
|
||||
ASSERT_THROWS((too_small_vc1c = force_move(vc13)), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vc2c = force_move(vc23)), std::invalid_argument);
|
||||
|
||||
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.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>);
|
||||
|
||||
|
||||
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>);
|
||||
decltype(vs11) vs1;
|
||||
decltype(vs21) vs2;
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<1>()> vs3;
|
||||
cc::const_vector<const char *, test_defs::get<const char *>::capacity<2>()> vs4;
|
||||
cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<1>() - 1)> too_small_vs1c;
|
||||
cc::const_vector<const char *, (test_defs::get<const char *>::arr_len<2>() - 1)> too_small_vs2c;
|
||||
|
||||
|
||||
vs1 = force_move(vs11);
|
||||
vs2 = force_move(vs21);
|
||||
vs3 = force_move(vs12);
|
||||
vs4 = force_move(vs22);
|
||||
|
||||
ASSERT_THROWS((too_small_vs1c = force_move(vs13)), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vs2c = force_move(vs23)), std::invalid_argument);
|
||||
|
||||
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.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>);
|
||||
decltype(vo11) vo1;
|
||||
decltype(vo21) vo2;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4;
|
||||
cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<1>() - 1)> too_small_vo1c;
|
||||
cc::const_vector<TestStruct, (test_defs::get<TestStruct>::arr_len<2>() - 1)> too_small_vo2c;
|
||||
|
||||
|
||||
vo1 = force_move(vo11);
|
||||
vo2 = force_move(vo21);
|
||||
vo3 = force_move(vo12);
|
||||
vo4 = force_move(vo22);
|
||||
|
||||
ASSERT_THROWS((too_small_vo1c = force_move(vo13)), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vo2c = force_move(vo23)), std::invalid_argument);
|
||||
|
||||
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.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)
|
||||
("const_vector::operator=(const value_type (&array)[])", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::arr_len<1>()> vi1;
|
||||
cc::const_vector<int, test_defs::get<int>::arr_len<2>()> vi2;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4;
|
||||
cc::const_vector<int, test_defs::get<int>::arr_len<1>() - 1> too_small_vi1;
|
||||
cc::const_vector<int, test_defs::get<int>::arr_len<2>() - 1> too_small_vi2;
|
||||
|
||||
vi1 = test_defs::get<int>::arr<1>;
|
||||
vi2 = test_defs::get<int>::arr<2>;
|
||||
vi3 = test_defs::get<int>::arr<1>;
|
||||
vi4 = test_defs::get<int>::arr<2>;
|
||||
|
||||
ASSERT_THROWS((too_small_vi1 = test_defs::get<int>::arr<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vi1 = test_defs::get<int>::arr<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vi1.size() == test_defs::get<int>::arr_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::arr_len<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(vi1, test_defs::get<int>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi2, test_defs::get<int>::arr<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<char, test_defs::get<char>::arr_len<1>()> vc1;
|
||||
cc::const_vector<char, test_defs::get<char>::arr_len<2>()> vc2;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc3;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc4;
|
||||
cc::const_vector<char, test_defs::get<char>::arr_len<1>() - 1> too_small_vc1;
|
||||
cc::const_vector<char, test_defs::get<char>::arr_len<2>() - 1> too_small_vc2;
|
||||
|
||||
vc1 = test_defs::get<char>::arr<1>;
|
||||
vc2 = test_defs::get<char>::arr<2>;
|
||||
vc3 = test_defs::get<char>::arr<1>;
|
||||
vc4 = test_defs::get<char>::arr<2>;
|
||||
|
||||
ASSERT_THROWS((too_small_vc1 = test_defs::get<char>::arr<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vc1 = test_defs::get<char>::arr<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vc1.size() == test_defs::get<char>::arr_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::arr_len<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(vc1, test_defs::get<char>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc2, test_defs::get<char>::arr<2>);
|
||||
ASSERT_VEC_ARR_EQ(vc3, test_defs::get<char>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc4, test_defs::get<char>::arr<2>);
|
||||
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::arr_len<1>()> vs1;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::arr_len<2>()> vs2;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::capacity<1>()> vs3;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::capacity<2>()> vs4;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::arr_len<1>() - 1> too_small_vs1;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::arr_len<2>() - 1> too_small_vs2;
|
||||
|
||||
vs1 = test_defs::get<const char*>::arr<1>;
|
||||
vs2 = test_defs::get<const char*>::arr<2>;
|
||||
vs3 = test_defs::get<const char*>::arr<1>;
|
||||
vs4 = test_defs::get<const char*>::arr<2>;
|
||||
|
||||
ASSERT_THROWS((too_small_vs1 = test_defs::get<const char*>::arr<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vs1 = test_defs::get<const char*>::arr<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vs1.size() == test_defs::get<const char*>::arr_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char*>::arr_len<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(vs1, test_defs::get<const char*>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs2, test_defs::get<const char*>::arr<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<TestStruct, test_defs::get<TestStruct>::arr_len<1>()> vo1;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::arr_len<2>()> vo2;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::arr_len<1>() - 1> too_small_vo1;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::arr_len<2>() - 1> too_small_vo2;
|
||||
|
||||
vo1 = test_defs::get<TestStruct>::arr<1>;
|
||||
vo2 = test_defs::get<TestStruct>::arr<2>;
|
||||
vo3 = test_defs::get<TestStruct>::arr<1>;
|
||||
vo4 = test_defs::get<TestStruct>::arr<2>;
|
||||
|
||||
ASSERT_THROWS((too_small_vo1 = test_defs::get<TestStruct>::arr<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vo1 = test_defs::get<TestStruct>::arr<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::arr_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::arr_len<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(vo1, test_defs::get<TestStruct>::arr<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo2, test_defs::get<TestStruct>::arr<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)
|
||||
("const_vector::operator=(std::initializer_list<value_type> values)", []() constexpr {
|
||||
|
||||
cc::const_vector<int, test_defs::get<int>::il_len<1>()> vi1;
|
||||
cc::const_vector<int, test_defs::get<int>::il_len<2>()> vi2;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<1>()> vi3;
|
||||
cc::const_vector<int, test_defs::get<int>::capacity<2>()> vi4;
|
||||
cc::const_vector<int, test_defs::get<int>::il_len<1>() - 1> too_small_vi1;
|
||||
cc::const_vector<int, test_defs::get<int>::il_len<2>() - 1> too_small_vi2;
|
||||
|
||||
OPERATOR_EQ_IL(vi1, test_defs::get<int>::i_list<1>, test_defs::get<int>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vi2, test_defs::get<int>::i_list<2>, test_defs::get<int>::il_len<2>());
|
||||
OPERATOR_EQ_IL(vi3, test_defs::get<int>::i_list<1>, test_defs::get<int>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vi4, test_defs::get<int>::i_list<2>, test_defs::get<int>::il_len<2>());
|
||||
|
||||
ASSERT_THROWS((too_small_vi1 = test_defs::get<int>::i_list<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vi1 = test_defs::get<int>::i_list<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vi1.size() == test_defs::get<int>::il_len<1>());
|
||||
ASSERT(vi2.size() == test_defs::get<int>::il_len<2>());
|
||||
ASSERT(vi3.size() == test_defs::get<int>::il_len<1>());
|
||||
ASSERT(vi4.size() == test_defs::get<int>::il_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_VEC_ARR_EQ(vi3, test_defs::get<int>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vi4, test_defs::get<int>::i_list<2>);
|
||||
|
||||
cc::const_vector<char, test_defs::get<char>::il_len<1>()> vc1;
|
||||
cc::const_vector<char, test_defs::get<char>::il_len<2>()> vc2;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<1>()> vc3;
|
||||
cc::const_vector<char, test_defs::get<char>::capacity<2>()> vc4;
|
||||
cc::const_vector<char, test_defs::get<char>::il_len<1>() - 1> too_small_vc1;
|
||||
cc::const_vector<char, test_defs::get<char>::il_len<2>() - 1> too_small_vc2;
|
||||
|
||||
OPERATOR_EQ_IL(vc1, test_defs::get<char>::i_list<1>, test_defs::get<char>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vc2, test_defs::get<char>::i_list<2>, test_defs::get<char>::il_len<2>());
|
||||
OPERATOR_EQ_IL(vc3, test_defs::get<char>::i_list<1>, test_defs::get<char>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vc4, test_defs::get<char>::i_list<2>, test_defs::get<char>::il_len<2>());
|
||||
|
||||
ASSERT_THROWS((too_small_vc1 = test_defs::get<char>::i_list<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vc1 = test_defs::get<char>::i_list<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vc1.size() == test_defs::get<char>::il_len<1>());
|
||||
ASSERT(vc2.size() == test_defs::get<char>::il_len<2>());
|
||||
ASSERT(vc3.size() == test_defs::get<char>::il_len<1>());
|
||||
ASSERT(vc4.size() == test_defs::get<char>::il_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_VEC_ARR_EQ(vc3, test_defs::get<char>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vc4, test_defs::get<char>::i_list<2>);
|
||||
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::il_len<1>()> vs1;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::il_len<2>()> vs2;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::capacity<1>()> vs3;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::capacity<2>()> vs4;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::il_len<1>() - 1> too_small_vs1;
|
||||
cc::const_vector<const char*, test_defs::get<const char*>::il_len<2>() - 1> too_small_vs2;
|
||||
|
||||
OPERATOR_EQ_IL(vs1, test_defs::get<const char*>::i_list<1>, test_defs::get<const char*>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vs2, test_defs::get<const char*>::i_list<2>, test_defs::get<const char*>::il_len<2>());
|
||||
OPERATOR_EQ_IL(vs3, test_defs::get<const char*>::i_list<1>, test_defs::get<const char*>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vs4, test_defs::get<const char*>::i_list<2>, test_defs::get<const char*>::il_len<2>());
|
||||
|
||||
ASSERT_THROWS((too_small_vs1 = test_defs::get<const char*>::i_list<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vs1 = test_defs::get<const char*>::i_list<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vs1.size() == test_defs::get<const char*>::il_len<1>());
|
||||
ASSERT(vs2.size() == test_defs::get<const char*>::il_len<2>());
|
||||
ASSERT(vs3.size() == test_defs::get<const char*>::il_len<1>());
|
||||
ASSERT(vs4.size() == test_defs::get<const char*>::il_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_VEC_ARR_EQ(vs3, test_defs::get<const char*>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vs4, test_defs::get<const char*>::i_list<2>);
|
||||
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<1>()> vo1;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<2>()> vo2;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<1>()> vo3;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::capacity<2>()> vo4;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<1>() - 1> too_small_vo1;
|
||||
cc::const_vector<TestStruct, test_defs::get<TestStruct>::il_len<2>() - 1> too_small_vo2;
|
||||
|
||||
OPERATOR_EQ_IL(vo1, test_defs::get<TestStruct>::i_list<1>, test_defs::get<TestStruct>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vo2, test_defs::get<TestStruct>::i_list<2>, test_defs::get<TestStruct>::il_len<2>());
|
||||
OPERATOR_EQ_IL(vo3, test_defs::get<TestStruct>::i_list<1>, test_defs::get<TestStruct>::il_len<1>());
|
||||
OPERATOR_EQ_IL(vo4, test_defs::get<TestStruct>::i_list<2>, test_defs::get<TestStruct>::il_len<2>());
|
||||
|
||||
ASSERT_THROWS((too_small_vo1 = test_defs::get<TestStruct>::i_list<1>), std::invalid_argument);
|
||||
ASSERT_THROWS((too_small_vo1 = test_defs::get<TestStruct>::i_list<2>), std::invalid_argument);
|
||||
|
||||
ASSERT(vo1.size() == test_defs::get<TestStruct>::il_len<1>());
|
||||
ASSERT(vo2.size() == test_defs::get<TestStruct>::il_len<2>());
|
||||
ASSERT(vo3.size() == test_defs::get<TestStruct>::il_len<1>());
|
||||
ASSERT(vo4.size() == test_defs::get<TestStruct>::il_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_VEC_ARR_EQ(vo3, test_defs::get<TestStruct>::i_list<1>);
|
||||
ASSERT_VEC_ARR_EQ(vo4, test_defs::get<TestStruct>::i_list<2>);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
|
||||
("const_vector::assign(size_type count, const value_type& value)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES(([]<typename T>() constexpr {
|
||||
|
||||
cc::const_vector v1(test_defs::get<T>::template arr<1>);
|
||||
cc::const_vector v2(test_defs::get<T>::template arr<2>);
|
||||
cc::const_vector<T, test_defs::get<T>::template capacity<1>()> v3;
|
||||
|
||||
auto count1 = test_defs::get<T>::template arr_len<1>() / 2;
|
||||
auto count2 = test_defs::get<T>::template arr_len<2>() / 2;
|
||||
|
||||
v1.assign(count1, test_defs::get<T>::template value<1>());
|
||||
v2.assign(count2, test_defs::get<T>::template value<2>());
|
||||
v3.assign(test_defs::get<T>::template capacity<1>() + 1, test_defs::get<T>::template value<1>());
|
||||
|
||||
ASSERT_TYPE(v1.size() == count1, T);
|
||||
ASSERT_TYPE(v2.size() == count2, T);
|
||||
ASSERT_TYPE_ALL_VEC_EQ(v1, test_defs::get<T>::template value<1>(), T);
|
||||
ASSERT_TYPE_ALL_VEC_EQ(v2, test_defs::get<T>::template value<2>(), T);
|
||||
|
||||
ASSERT_TYPE(v3.size() == test_defs::get<T>::template capacity<1>(), T);
|
||||
ASSERT_TYPE_ALL_VEC_EQ(v1, test_defs::get<T>::template value<1>(), T);
|
||||
|
||||
return TEST_PASS();
|
||||
}), int, char, const char*, TestStruct);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::assign(InputIt first, InputIt last)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t n, typename params>() constexpr {
|
||||
constexpr std::size_t N = n+1;
|
||||
cc::const_vector<T, test_defs::get<T>::template arr_len<N>()> v1;
|
||||
cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v2;
|
||||
cc::const_vector<T, test_defs::get<T>::template il_len<N>()> v3;
|
||||
cc::const_vector<T, test_defs::get<T>::template arr_len<N>() - 1> v4;
|
||||
|
||||
std::vector<T> container = test_defs::get<T>::template i_list<N>;
|
||||
|
||||
v1.assign(std::begin(test_defs::get<T>::template arr<N>), std::end(test_defs::get<T>::template arr<N>));
|
||||
v2.assign(container.begin(), container.end());
|
||||
v3.assign(container.begin(), std::next(container.begin(), test_defs::get<T>::template il_len<N>() / 2));
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS(
|
||||
(v4.assign(std::begin(test_defs::get<T>::template arr<N>),
|
||||
std::end(test_defs::get<T>::template arr<N>))), std::invalid_argument, T, N);
|
||||
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, test_defs::get<T>::template arr<N>, T, N);
|
||||
ASSERT_TYPE_NUM(v1.size() == test_defs::get<T>::template arr_len<N>(), T, N);
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v2, container, T, N);
|
||||
ASSERT_TYPE_NUM(v2.size() == container.size(), T, N);
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v3, container, T, N);
|
||||
ASSERT_TYPE_NUM(v3.size() == container.size() / 2, T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 3, int, char, const char *, TestStruct);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
("const_vector::assign(std::initializer_list<value_type> values)", []() constexpr {
|
||||
|
||||
REPEAT_FOR_TYPES_N(([]<typename T, std::size_t N, typename Ctx>() constexpr {
|
||||
|
||||
cc::const_vector<T, (test_params<"ilist", Ctx>::get()).size()> v1;
|
||||
cc::const_vector<T, (test_params<"ilist", Ctx>::get()).size() - 1> v2;
|
||||
|
||||
v1.assign(test_params<"ilist", Ctx>::get());
|
||||
|
||||
ASSERT_TYPE_NUM_VEC_ARR_EQ(v1, (test_params<"ilist", Ctx>::get()), T, N);
|
||||
ASSERT_TYPE_NUM((v1.size() == test_params<"ilist", Ctx>::get().size()), T, N);
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS(v2.assign(test_params<"ilist", Ctx>::get()), std::invalid_argument, T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
|
||||
("const_vector::at(size_type pos)", []() constexpr {
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
|
||||
/*("const_vector", []() constexpr {
|
||||
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)*/
|
||||
/*("const_vector(const_vector&& other)", []() constexpr {
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)
|
||||
*/;
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL);
|
||||
|
||||
int main() {
|
||||
return tests.run();
|
||||
|
|
|
|||
|
|
@ -0,0 +1,34 @@
|
|||
#include <const_vector.hpp>
|
||||
|
||||
#include <test.hpp>
|
||||
#include "test_params.h"
|
||||
|
||||
constexpr test_suite tests = define_tests("Data Access")
|
||||
("const_vector::at(size_type pos)", []() 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">);
|
||||
const cc::const_vector<T, test_params<"arr", Ctx>::get_arr_len() + 1> cv(test_context_params<T, N>::template value<"arr">);
|
||||
|
||||
for (int i = 0; i < test_params<"arr", Ctx>::get_arr_len(); ++i) {
|
||||
ASSERT_TYPE_NUM((v.at(i) == test_params<"arr", Ctx>::get()[i]), T, N);
|
||||
ASSERT_TYPE_NUM((cv.at(i) == test_params<"arr", Ctx>::get()[i]), T, N);
|
||||
}
|
||||
|
||||
ASSERT_TYPE_NUM_THROWS(v.at(test_params<"arr", Ctx>::get_arr_len()), std::out_of_range, T, N);
|
||||
ASSERT_TYPE_NUM_THROWS(cv.at(test_params<"arr", Ctx>::get_arr_len()), std::out_of_range, T, N);
|
||||
|
||||
v.at(v.size() / 2) = test_params<"value", Ctx>::get();
|
||||
|
||||
ASSERT_TYPE_NUM((v.data()[v.size() / 2] == test_params<"value", Ctx>::get()), T, N);
|
||||
|
||||
return TEST_PASS();
|
||||
}), 2, int, char, const char *, TestObj);
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL);
|
||||
|
||||
int main() {
|
||||
return tests.run();
|
||||
}
|
||||
|
|
@ -56,14 +56,14 @@ template<> template<> constexpr std::initializer_list<TestObj> test_context_para
|
|||
GEN_TEST_OBJ_FROM_ARR(1, 6),
|
||||
GEN_TEST_OBJ_FROM_ARR(1, 7) };
|
||||
|
||||
template<> template<> constexpr std::size_t test_context_params<int, 1>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<char, 1>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<const char *, 1>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<TestObj, 1>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<int, 2>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<char, 2>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<const char *, 2>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<TestObj, 2>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<int, 0>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<char, 0>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<const char *, 0>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<TestObj, 0>::value<"capacity"> = 10;
|
||||
template<> template<> constexpr std::size_t test_context_params<int, 1>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<char, 1>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<const char *, 1>::value<"capacity"> = 200;
|
||||
template<> template<> constexpr std::size_t test_context_params<TestObj, 1>::value<"capacity"> = 200;
|
||||
|
||||
template<> template<> constexpr std::size_t test_context_params<int, 0>::value<"size"> = 25;
|
||||
template<> template<> constexpr std::size_t test_context_params<char, 0>::value<"size"> = 25;
|
||||
|
|
|
|||
Loading…
Reference in New Issue