Patrick
/
const_container
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Patrick:6a05192db3868eb935b3bb3b6053cc02f13b2b1f
Branches Tags
Patrick:master
...
compare: Patrick:1fe0db92475f29ae3fe419d715db3d4cbc57b190
Branches Tags
Patrick:master

7 Commits
6a05192db3 ... 1fe0db9247

Author SHA1 Message Date
Patrick 1fe0db9247 added exception tests, tests for move constructor and all operator= 2024-07-22 23:34:29 +02:00
Patrick 43a62df9e1 added OPERATOR_EQ_IL 2024-07-22 23:32:52 +02:00
Patrick 5fd03b408b added location to asserts and ASSERT_THROWS 2024-07-22 23:32:31 +02:00
Patrick f08c2890f1 updated wrong noexcepts and throw statements 2024-07-22 23:30:24 +02:00
Patrick 67d3a2f4cf implemented move for other with different capacity 2024-07-22 22:51:22 +02:00
Patrick 297c42b176 added CREATE_FROM_IL 2024-07-22 20:36:19 +02:00
Patrick 46bf398a78 fixed test not running 2024-07-22 20:35:37 +02:00
4 changed files with 681 additions and 93 deletions
Show Stats Expand all files Collapse all files

55
include/const_vector.hpp
View File

@ -48,7 +48,7 @@ namespace cc {
template <std::size_t N2>
constexpr explicit const_vector(const value_type (&array)[N2]) noexcept;
constexpr const_vector(std::initializer_list<value_type> values) noexcept;
constexpr const_vector(std::initializer_list<value_type> values);
template<std::input_iterator InputIt>
constexpr const_vector(InputIt first, InputIt last);
@ -57,17 +57,21 @@ namespace cc {
template <std::size_t N2>
constexpr const_vector(const const_vector<value_type, N2>& other);
constexpr const_vector(const_vector&& other) noexcept;
template <std::size_t N2>
constexpr const_vector(const_vector<value_type, N2>&& other);
constexpr ~const_vector() = default; // elements in static array should be destroyed automatically
constexpr const_vector<T, N>& operator=(const const_vector& other); // needed to handle *this = *this
constexpr const_vector<T, N>& operator=(const const_vector& other) noexcept; // needed to handle *this = *this
template <std::size_t N2>
constexpr const_vector<T, N>& operator=(const const_vector<value_type, N2>& other);
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
template <std::size_t N2>
constexpr const_vector<T, N>& operator=(const value_type (&array)[N2]) noexcept;
constexpr const_vector<T, N>& operator=(std::initializer_list<value_type> values) noexcept;
constexpr const_vector<T, N>& operator=(const value_type (&array)[N2]);
constexpr const_vector<T, N>& operator=(std::initializer_list<value_type> values);
constexpr void assign(size_type count, const value_type& value) noexcept;
template<std::input_iterator InputIt>
@ -136,9 +140,8 @@ namespace cc {
template<std::size_t N2>
constexpr void swap(const_vector<T, N2>& other);
#ifdef UNIT_TEST
friend test_const_vector;
#endif
template <typename T2, std::size_t N2>
friend class const_vector;
};
@ -214,9 +217,10 @@ namespace cc {
}
template<typename T, std::size_t N>
constexpr const_vector<T, N>::const_vector(std::initializer_list<value_type> values) noexcept
constexpr const_vector<T, N>::const_vector(std::initializer_list<value_type> values)
: _size(values.size())
{
if (values.size() > N) throw std::invalid_argument("Initializer list in assign has more elements than size" + std::to_string(values.size()) + ">=" + std::to_string(N));
std::move(values.begin(), values.end(), _arr);
}
@ -253,11 +257,23 @@ namespace cc {
std::move(other.begin(), other.end(), _arr);
}
template<typename T, std::size_t N>
template<std::size_t N2>
constexpr const_vector<T, N>::const_vector(const_vector<value_type, N2> &&other)
: _size(other._size)
{
if (_len <= other.size()) throw std::invalid_argument("size of other has to be equal to or smaller than this");
std::move(other.begin(), other.end(), _arr);
}
template<typename T, std::size_t N>
constexpr const_vector<T, N> &const_vector<T, N>::operator=(const const_vector &other)
constexpr const_vector<T, N> &const_vector<T, N>::operator=(const const_vector &other) noexcept
{
if (this == &other) return *this;
// event though assign may throw an exception noexcept for this operator should be fine,
// as std::distance(other.begin(), other.end()) cannot be greater than the capacity,
// because the signatures would have to differ
assign(other.begin(), other.end());
return *this;
@ -270,7 +286,7 @@ namespace cc {
if (other.size() > _len) throw std::invalid_argument("size of other has to be equal to or smaller than this");
// this is not necessary, as it should call the non templated operator=
// (and it throws an error without a cast)
// (and throws an error without a cast)
//if (this == &other) return *this;
assign(other.begin(), other.end());
@ -294,14 +310,27 @@ namespace cc {
template<typename T, std::size_t N>
template<std::size_t N2>
constexpr const_vector<T, N> &const_vector<T, N>::operator=(const value_type (&array)[N2]) noexcept
constexpr const_vector<T, N> &const_vector<T, N>::operator=(const_vector<value_type, N2> &&other)
{
if (other.size() > _len) throw std::invalid_argument("size of other has to be equal to or smaller than this");
clear();
std::move(other.begin(), other.end(), _arr);
_size = other._size;
return *this;
}
template<typename T, std::size_t N>
template<std::size_t N2>
constexpr const_vector<T, N> &const_vector<T, N>::operator=(const value_type (&array)[N2])
{
assign(std::begin(array), std::end(array));
return *this;
}
template<typename T, std::size_t N>
constexpr const_vector<T, N> &const_vector<T, N>::operator=(std::initializer_list<value_type> values) noexcept
constexpr const_vector<T, N> &const_vector<T, N>::operator=(std::initializer_list<value_type> values)
{
assign(std::move(values));
return *this;
@ -321,7 +350,7 @@ namespace cc {
constexpr void const_vector<T, N>::assign(InputIt first, InputIt last)
{
auto distance = std::distance(first, last);
if (distance > N) throw std::invalid_argument("Iterator distance in assign surpasses size" + std::to_string(distance) + ">=" + std::to_string(N));
if (distance > N) throw std::invalid_argument("Iterator distance in assign surpasses size " + std::to_string(distance) + " >= " + std::to_string(N));
_size = distance;
std::copy(first, last, begin());
}

38
test/common_helper/test.hpp
View File

@ -13,16 +13,22 @@
#include <tuple>
#include <numeric>
#define _EXPAND_STR(s) #s
#define _EXPAND_MACRO(s) _EXPAND_STR(s)
#define _LOCATION " (at " _EXPAND_MACRO(__FILE__) ":" _EXPAND_MACRO(__LINE__) ")"
#define TEST_FAIL(msg) ret_val_s { "", ReturnCode::FAILED, msg }
#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 ASSERT(condition) ASSERT_MSG(condition, #condition)
#define ASSERT(condition) ASSERT_MSG(condition, #condition "" _LOCATION)
#define ASSERT_MSG(condition, msg) { if (!(condition)) return TEST_FAIL(msg); } static_assert(true, "")
#define ASSERT_ALL_EQ(first, last, eq) ASSERT_MSG(std::all_of(first, last, all_eq_arr_elem_test_func(eq)), "Not all elements in (" #first ", " #last ") equal " #eq)
#define ASSERT_C_ARR_EQ(first, last, eq) ASSERT_MSG(std::equal(first, last, eq, all_eq_arr_arr_test_func<decltype(eq)>()), "Elements in (" #first ", " #last ") and " #eq " differ")
#define ASSERT_ITER_EQ(first, last, eq) ASSERT_MSG(std::equal(first, last, (eq).begin(), all_eq_arr_arr_test_func<std::iterator_traits<decltype(eq)::iterator>::value_type>()), "Elements in (" #first ", " #last ") and " #eq " differ")
#define ASSERT_ALL_EQ(first, last, eq) ASSERT_MSG(std::all_of(first, last, all_eq_arr_elem_test_func(eq)), "Not all elements in (" #first ", " #last ") equal " #eq "" _LOCATION)
#define ASSERT_C_ARR_EQ(first, last, eq) ASSERT_MSG(std::equal(first, last, eq, all_eq_arr_arr_test_func<decltype(eq)>()), "Elements in (" #first ", " #last ") and " #eq " differ" _LOCATION)
#define ASSERT_ITER_EQ(first, last, eq) ASSERT_MSG(std::equal(first, last, (eq).begin(), all_eq_arr_arr_test_func<std::iterator_traits<decltype(eq)::iterator>::value_type>()), "Elements in (" #first ", " #last ") and " #eq " differ" _LOCATION)
#define ASSERT_THROWS(operation, exception_type) if not consteval { try { operation; ASSERT_MSG(false, #operation " did not throw " #exception_type _LOCATION); } catch (exception_type &e) {} } static_assert(true, "")
template<typename T>
constexpr auto all_eq_arr_elem_test_func(T&& eq) {
@ -247,9 +253,27 @@ inline std::ostream& operator<<(std::ostream& os, ReturnCode rc) {
}
}
template <template<typename T, std::initializer_list<T> il> typename Callee>
constexpr void expand_from_ilist() {
return Callee { };
#define CREATE_FROM_IL(type, il, len) \
([]<std::size_t N, typename ArgType>(std::initializer_list<ArgType> args) { \
auto creator = [&args] <std::size_t ..._idx> (std::index_sequence<_idx...>) { \
return type { (*std::next(std::begin(args), _idx))... }; \
}; \
return creator(std::make_index_sequence<N>()); \
}).operator()<len>(il)
#define OPERATOR_EQ_IL(obj, il, len) \
([&]<std::size_t N, typename ArgType>(std::initializer_list<ArgType> args) { \
auto creator = [&] <std::size_t ..._idx> (std::index_sequence<_idx...>) { \
return obj = { (*std::next(std::begin(args), _idx))... }; \
}; \
return creator(std::make_index_sequence<N>()); \
}).operator()<len>(il)
template<typename T>
constexpr typename std::remove_cvref_t<T>&& force_move(T&& obj) {
return static_cast<std::remove_cvref_t<T>&&>(obj);
}
#endif //CONST_CONTAINER_TEST_HPP_

675
test/const_vector/const_vector_constructor.test.cpp
View File

@ -1,3 +1,5 @@
#pragma clang diagnostic push
#pragma ide diagnostic ignored "readability-container-size-empty"
#include <const_vector.hpp>
#include "test.hpp"
@ -6,9 +8,9 @@
#define ASSERT_ALL_VEC_EQ(vec, eq) ASSERT_ALL_EQ((vec).begin(), (vec).end(), eq)
#define ASSERT_RANGE_VEC_EQ(vec, startI, endI, eq) ASSERT_ALL_EQ(((vec).data() + startI), ((vec).data() + endI), eq)
#define ASSERT_VEC_ARR_EQ(vec, eq) ASSERT_C_ARR_EQ((vec).data(), (vec).data() + (vec).size(), eq)
#define ASSERT_VEC_ARR_EQ(vec, eq) ASSERT_C_ARR_EQ((vec).data(), (vec).data() + (vec).size(), std::begin(eq))
#define ASSERT_VEC_EQ(vec1, vec2) ASSERT_C_ARR_EQ((vec1).data(), (vec1).data() + (vec1).size(), (vec2).data())
#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_C_ARR_EQ(((vec).begin() + startI), ((vec).begin() + endI), (eq))
#define ASSERT_RANGE_VEC_ARR_EQ(vec, startI, endI, eq) ASSERT_C_ARR_EQ(((vec).begin() + startI), ((vec).begin() + endI), std::begin(eq))
constexpr test_suite tests = define_tests("Tests")
("const_vector()", []() constexpr {
@ -64,8 +66,6 @@ constexpr test_suite tests = define_tests("Tests")
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>());
@ -165,9 +165,7 @@ constexpr test_suite tests = define_tests("Tests")
return TEST_PASS();
}, EvalFlag::RUNTIME_CONSTEVAL)
("const_vector(const value_type (&array)[N])", []() constexpr{
("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>);
@ -249,16 +247,20 @@ constexpr test_suite tests = define_tests("Tests")
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(std::initializer_list<value_type> list)", []() constexpr{
cc::const_vector vi1(test_defs::get<int>::i_list<1>);
cc::const_vector vi2(test_defs::get<int>::i_list<2>);
("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>);
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);
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>());
@ -275,11 +277,14 @@ constexpr test_suite tests = define_tests("Tests")
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>::i_list<1>);
cc::const_vector vc2(test_defs::get<char>::i_list<2>);
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>());
@ -296,11 +301,14 @@ constexpr test_suite tests = define_tests("Tests")
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 *>::i_list<1>);
cc::const_vector vs2(test_defs::get<const char *>::i_list<2>);
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>());
@ -315,11 +323,14 @@ constexpr test_suite tests = define_tests("Tests")
ASSERT_RANGE_VEC_ARR_EQ(vs4, 0, test_defs::get<const char *>::arr_len<2>(), test_defs::get<const char *>::i_list<2>);
cc::const_vector vo1(test_defs::get<TestStruct>::i_list<1>);
cc::const_vector vo2(test_defs::get<TestStruct>::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>());
@ -337,8 +348,7 @@ constexpr test_suite tests = define_tests("Tests")
return TEST_PASS();
}, EvalFlag::RUNTIME_CONSTEVAL)
("const_vector(InputIt first, InputIt last)", []() constexpr{
("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>));
@ -429,8 +439,7 @@ constexpr test_suite tests = define_tests("Tests")
return TEST_PASS();
}, EvalFlag::RUNTIME_CONSTEVAL)
("const_vector(const const_vector& other)", []() constexpr{
("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>);
@ -517,77 +526,597 @@ constexpr test_suite tests = define_tests("Tests")
return TEST_PASS();
}, EvalFlag::RUNTIME_CONSTEVAL)
("const_vector(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 vi3(const_cast<std::remove_const_t<decltype(vi1)>&&>(vi1));
cc::const_vector vi4(const_cast<std::remove_const_t<decltype(vi2)>&&>(vi2));
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);
ASSERT(vi3.capacity() == vi1c.capacity());
ASSERT(vi4.capacity() == vi2c.capacity());
ASSERT(vi3.size() == vi1c.size());
ASSERT(vi4.size() == vi2c.size());
ASSERT_VEC_EQ(vi3, vi1c);
ASSERT_VEC_EQ(vi4, vi2c);
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 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));
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 vc3(const_cast<std::remove_const_t<decltype(vc1)>&&>(vc1));
cc::const_vector vc4(const_cast<std::remove_const_t<decltype(vc2)>&&>(vc2));
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(vi3.capacity() == vi1c.capacity());
ASSERT(vi4.capacity() == vi2c.capacity());
ASSERT(vi3.size() == vi1c.size());
ASSERT(vi4.size() == vi2c.size());
ASSERT_VEC_EQ(vi3, vi1c);
ASSERT_VEC_EQ(vi4, vi2c);
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>);
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));
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 vs3(const_cast<std::remove_const_t<decltype(vs1)>&&>(vs1));
cc::const_vector vs4(const_cast<std::remove_const_t<decltype(vs2)>&&>(vs2));
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(vs3.capacity() == vs1c.capacity());
ASSERT(vs4.capacity() == vs2c.capacity());
ASSERT(vs3.size() == vs1c.size());
ASSERT(vs4.size() == vs2c.size());
ASSERT_VEC_EQ(vs3, vs1c);
ASSERT_VEC_EQ(vs4, vs2c);
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));
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 vo3(const_cast<std::remove_const_t<decltype(vo1)>&&>(vo1));
cc::const_vector vo4(const_cast<std::remove_const_t<decltype(vo2)>&&>(vo2));
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(vo3.capacity() == vo1c.capacity());
ASSERT(vo4.capacity() == vo2c.capacity());
ASSERT(vo3.size() == vo1c.size());
ASSERT(vo4.size() == vo2c.size());
ASSERT_VEC_EQ(vo3, vo1c);
ASSERT_VEC_EQ(vo4, vo2c);
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)
("const_vector::operator=(const const_vector& other)", []() constexpr {
/*("const_vector(const_vector&& other)", []() {
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(const_vector&& other)", []() constexpr {
return TEST_PASS();
}, EvalFlag::RUNTIME_CONSTEVAL)*/
;
int main() {
return tests.run();
}
}
#pragma clang diagnostic pop

6
test/const_vector/test_args.h
View File

@ -58,6 +58,9 @@ struct test_defs {
template<std::size_t nr>
static consteval std::size_t arr_len();
template<std::size_t nr>
static consteval std::size_t il_len();
template<std::size_t nr>
static consteval std::size_t capacity();
@ -117,6 +120,9 @@ template<std::size_t nr>
consteval std::size_t test_defs::get<T>::arr_len() { return C_ARR_LEN(arr<nr>); }
template<typename T>
template<std::size_t nr>
consteval std::size_t test_defs::get<T>::il_len() { return i_list<nr>.size(); }
template<typename T>
template<std::size_t nr>
consteval std::size_t test_defs::get<T>::capacity() { return 0; }
template<typename T>
template<std::size_t nr>