added exception tests, tests for move constructor and all operator=
This commit is contained in:
parent
43a62df9e1
commit
1fe0db9247
|
|
@ -1,3 +1,5 @@
|
|||
#pragma clang diagnostic push
|
||||
#pragma ide diagnostic ignored "readability-container-size-empty"
|
||||
#include <const_vector.hpp>
|
||||
|
||||
#include "test.hpp"
|
||||
|
|
@ -256,6 +258,9 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
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>());
|
||||
|
|
@ -277,6 +282,9 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
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>());
|
||||
|
|
@ -298,6 +306,9 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
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>());
|
||||
|
|
@ -317,6 +328,9 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
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>());
|
||||
|
|
@ -514,74 +528,595 @@ constexpr test_suite tests = define_tests("Tests")
|
|||
}, 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)", []() 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(const_vector&& other)", []() constexpr {
|
||||
|
||||
return TEST_PASS();
|
||||
}, EvalFlag::RUNTIME_CONSTEVAL)*/
|
||||
;
|
||||
|
||||
int main() {
|
||||
return tests.run();
|
||||
}
|
||||
}
|
||||
#pragma clang diagnostic pop
|
||||
Loading…
Reference in New Issue