From 1fe0db92475f29ae3fe419d715db3d4cbc57b190 Mon Sep 17 00:00:00 2001 From: Patrick Date: Mon, 22 Jul 2024 23:34:29 +0200 Subject: [PATCH] added exception tests, tests for move constructor and all operator= --- .../const_vector_constructor.test.cpp | 635 ++++++++++++++++-- 1 file changed, 585 insertions(+), 50 deletions(-) diff --git a/test/const_vector/const_vector_constructor.test.cpp b/test/const_vector/const_vector_constructor.test.cpp index 205f8f2..b028ad1 100644 --- a/test/const_vector/const_vector_constructor.test.cpp +++ b/test/const_vector/const_vector_constructor.test.cpp @@ -1,3 +1,5 @@ +#pragma clang diagnostic push +#pragma ide diagnostic ignored "readability-container-size-empty" #include #include "test.hpp" @@ -256,6 +258,9 @@ constexpr test_suite tests = define_tests("Tests") cc::const_vector::capacity<1>()> vi3(test_defs::get::i_list<1>); cc::const_vector::capacity<2>()> vi4(test_defs::get::i_list<2>); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<1>() - 1>), test_defs::get::i_list<1>, test_defs::get::il_len<1>())), std::invalid_argument); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<2>() - 1>), test_defs::get::i_list<2>, test_defs::get::il_len<2>())), std::invalid_argument); + ASSERT(vi1.capacity() == test_defs::get::arr_len<1>()); ASSERT(vi2.capacity() == test_defs::get::arr_len<2>()); ASSERT(vi1.size() == test_defs::get::arr_len<1>()); @@ -277,6 +282,9 @@ constexpr test_suite tests = define_tests("Tests") cc::const_vector::capacity<1>()> vc3(test_defs::get::i_list<1>); cc::const_vector::capacity<2>()> vc4(test_defs::get::i_list<2>); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<1>() - 1>), test_defs::get::i_list<1>, test_defs::get::il_len<1>())), std::invalid_argument); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<2>() - 1>), test_defs::get::i_list<2>, test_defs::get::il_len<2>())), std::invalid_argument); + ASSERT(vc1.capacity() == test_defs::get::arr_len<1>()); ASSERT(vc2.capacity() == test_defs::get::arr_len<2>()); ASSERT(vc1.size() == test_defs::get::arr_len<1>()); @@ -298,6 +306,9 @@ constexpr test_suite tests = define_tests("Tests") cc::const_vector::capacity<1>()> vs3(test_defs::get::i_list<1>); cc::const_vector::capacity<2>()> vs4(test_defs::get::i_list<2>); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<1>() - 1>), test_defs::get::i_list<1>, test_defs::get::il_len<1>())), std::invalid_argument); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<2>() - 1>), test_defs::get::i_list<2>, test_defs::get::il_len<2>())), std::invalid_argument); + ASSERT(vs1.capacity() == test_defs::get::arr_len<1>()); ASSERT(vs2.capacity() == test_defs::get::arr_len<2>()); ASSERT(vs1.size() == test_defs::get::arr_len<1>()); @@ -317,6 +328,9 @@ constexpr test_suite tests = define_tests("Tests") cc::const_vector::capacity<1>()> vo3(test_defs::get::i_list<1>); cc::const_vector::capacity<2>()> vo4(test_defs::get::i_list<2>); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<1>() - 1>), test_defs::get::i_list<1>, test_defs::get::il_len<1>())), std::invalid_argument); + ASSERT_THROWS((CREATE_FROM_IL((cc::const_vector::il_len<2>() - 1>), test_defs::get::i_list<2>, test_defs::get::il_len<2>())), std::invalid_argument); + ASSERT(vo1.capacity() == test_defs::get::arr_len<1>()); ASSERT(vo2.capacity() == test_defs::get::arr_len<2>()); ASSERT(vo1.size() == test_defs::get::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::arr<1>); - cc::const_vector vi2(test_defs::get::arr<2>); - cc::const_vector vi1c(vi1); - cc::const_vector vi2c(vi2); - cc::const_vector vi3(const_cast&&>(vi1)); - cc::const_vector vi4(const_cast&&>(vi2)); + cc::const_vector vi11(test_defs::get::arr<1>); + cc::const_vector vi21(test_defs::get::arr<2>); + cc::const_vector vi12(test_defs::get::arr<1>); + cc::const_vector vi22(test_defs::get::arr<2>); + cc::const_vector vi13(test_defs::get::arr<1>); + cc::const_vector vi23(test_defs::get::arr<2>); + cc::const_vector vi1(force_move(vi11)); + cc::const_vector vi2(force_move(vi21)); + cc::const_vector::capacity<1>()> vi3(force_move(vi12)); + cc::const_vector::capacity<2>()> vi4(force_move(vi22)); + + ASSERT_THROWS((cc::const_vector::arr_len<1>() - 1)>(force_move(vi13))), std::invalid_argument); + ASSERT_THROWS((cc::const_vector::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::arr_len<1>()); + ASSERT(vi2.capacity() == test_defs::get::arr_len<2>()); + ASSERT(vi1.size() == test_defs::get::arr_len<1>()); + ASSERT(vi2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi2, test_defs::get::arr<2>); + ASSERT(vi3.capacity() == test_defs::get::capacity<1>()); + ASSERT(vi4.capacity() == test_defs::get::capacity<2>()); + ASSERT(vi3.size() == test_defs::get::arr_len<1>()); + ASSERT(vi4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi4, test_defs::get::arr<2>); + cc::const_vector vc11(test_defs::get::arr<1>); + cc::const_vector vc21(test_defs::get::arr<2>); + cc::const_vector vc12(test_defs::get::arr<1>); + cc::const_vector vc22(test_defs::get::arr<2>); + cc::const_vector vc13(test_defs::get::arr<1>); + cc::const_vector vc23(test_defs::get::arr<2>); + cc::const_vector vc1(force_move(vc11)); + cc::const_vector vc2(force_move(vc21)); + cc::const_vector::capacity<1>()> vc3(force_move(vc12)); + cc::const_vector::capacity<2>()> vc4(force_move(vc22)); - cc::const_vector vc1(test_defs::get::arr<1>); - cc::const_vector vc2(test_defs::get::arr<2>); - cc::const_vector vc1c(vc1); - cc::const_vector vc2c(vc2); - cc::const_vector vc3(const_cast&&>(vc1)); - cc::const_vector vc4(const_cast&&>(vc2)); + ASSERT_THROWS((cc::const_vector::arr_len<1>() - 1)>(force_move(vc13))), std::invalid_argument); + ASSERT_THROWS((cc::const_vector::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::arr_len<1>()); + ASSERT(vc2.capacity() == test_defs::get::arr_len<2>()); + ASSERT(vc1.size() == test_defs::get::arr_len<1>()); + ASSERT(vc2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc2, test_defs::get::arr<2>); + ASSERT(vc3.capacity() == test_defs::get::capacity<1>()); + ASSERT(vc4.capacity() == test_defs::get::capacity<2>()); + ASSERT(vc3.size() == test_defs::get::arr_len<1>()); + ASSERT(vc4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc4, test_defs::get::arr<2>); + cc::const_vector vs11(test_defs::get::arr<1>); + cc::const_vector vs21(test_defs::get::arr<2>); + cc::const_vector vs12(test_defs::get::arr<1>); + cc::const_vector vs22(test_defs::get::arr<2>); + cc::const_vector vs13(test_defs::get::arr<1>); + cc::const_vector vs23(test_defs::get::arr<2>); + cc::const_vector vs1(force_move(vs11)); + cc::const_vector vs2(force_move(vs21)); + cc::const_vector::capacity<1>()> vs3(force_move(vs12)); + cc::const_vector::capacity<2>()> vs4(force_move(vs22)); - cc::const_vector vs1(test_defs::get::arr<1>); - cc::const_vector vs2(test_defs::get::arr<2>); - cc::const_vector vs1c(vs1); - cc::const_vector vs2c(vs2); - cc::const_vector vs3(const_cast&&>(vs1)); - cc::const_vector vs4(const_cast&&>(vs2)); + ASSERT_THROWS((cc::const_vector::arr_len<1>() - 1)>(force_move(vs13))), std::invalid_argument); + ASSERT_THROWS((cc::const_vector::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::arr_len<1>()); + ASSERT(vs2.capacity() == test_defs::get::arr_len<2>()); + ASSERT(vs1.size() == test_defs::get::arr_len<1>()); + ASSERT(vs2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs2, test_defs::get::arr<2>); + ASSERT(vs3.capacity() == test_defs::get::capacity<1>()); + ASSERT(vs4.capacity() == test_defs::get::capacity<2>()); + ASSERT(vs3.size() == test_defs::get::arr_len<1>()); + ASSERT(vs4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs4, test_defs::get::arr<2>); + cc::const_vector vo11(test_defs::get::arr<1>); + cc::const_vector vo21(test_defs::get::arr<2>); + cc::const_vector vo12(test_defs::get::arr<1>); + cc::const_vector vo22(test_defs::get::arr<2>); + cc::const_vector vo13(test_defs::get::arr<1>); + cc::const_vector vo23(test_defs::get::arr<2>); + cc::const_vector vo1(force_move(vo11)); + cc::const_vector vo2(force_move(vo21)); + cc::const_vector::capacity<1>()> vo3(force_move(vo12)); + cc::const_vector::capacity<2>()> vo4(force_move(vo22)); - cc::const_vector vo1(test_defs::get::arr<1>); - cc::const_vector vo2(test_defs::get::arr<2>); - cc::const_vector vo1c(vo1); - cc::const_vector vo2c(vo2); - cc::const_vector vo3(const_cast&&>(vo1)); - cc::const_vector vo4(const_cast&&>(vo2)); + ASSERT_THROWS((cc::const_vector::arr_len<1>() - 1)>(force_move(vo13))), std::invalid_argument); + ASSERT_THROWS((cc::const_vector::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::arr_len<1>()); + ASSERT(vo2.capacity() == test_defs::get::arr_len<2>()); + ASSERT(vo1.size() == test_defs::get::arr_len<1>()); + ASSERT(vo2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo2, test_defs::get::arr<2>); + ASSERT(vo3.capacity() == test_defs::get::capacity<1>()); + ASSERT(vo4.capacity() == test_defs::get::capacity<2>()); + ASSERT(vo3.size() == test_defs::get::arr_len<1>()); + ASSERT(vo4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo4, test_defs::get::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::arr<1>); + cc::const_vector vi2(test_defs::get::arr<2>); + decltype(vi1) vi1c; + decltype(vi2) vi2c; + cc::const_vector::capacity<1>()> vi3; + cc::const_vector::capacity<2>()> vi4; + cc::const_vector::arr_len<1>() - 1)> too_small_vi1c; + cc::const_vector::arr_len<2>() - 1)> too_small_vi2c; + cc::const_vector vc1(test_defs::get::arr<1>); + cc::const_vector vc2(test_defs::get::arr<2>); + decltype(vc1) vc1c; + decltype(vc2) vc2c; + cc::const_vector::capacity<1>()> vc3; + cc::const_vector::capacity<2>()> vc4; + cc::const_vector::arr_len<1>() - 1)> too_small_vc1c; + cc::const_vector::arr_len<2>() - 1)> too_small_vc2c; + + cc::const_vector vs1(test_defs::get::arr<1>); + cc::const_vector vs2(test_defs::get::arr<2>); + decltype(vs1) vs1c; + decltype(vs2) vs2c; + cc::const_vector::capacity<1>()> vs3; + cc::const_vector::capacity<2>()> vs4; + cc::const_vector::arr_len<1>() - 1)> too_small_vs1c; + cc::const_vector::arr_len<2>() - 1)> too_small_vs2c; + + cc::const_vector vo1(test_defs::get::arr<1>); + cc::const_vector vo2(test_defs::get::arr<2>); + decltype(vo1) vo1c; + decltype(vo2) vo2c; + cc::const_vector::capacity<1>()> vo3; + cc::const_vector::capacity<2>()> vo4; + cc::const_vector::arr_len<1>() - 1)> too_small_vo1c; + cc::const_vector::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::arr_len<1>()); + ASSERT(vi2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi2, test_defs::get::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::arr_len<1>()); + ASSERT(vc2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc2, test_defs::get::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::arr_len<1>()); + ASSERT(vs2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs2, test_defs::get::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::arr_len<1>()); + ASSERT(vo2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo2, test_defs::get::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::arr<1>); + cc::const_vector vi21(test_defs::get::arr<2>); + cc::const_vector vi12(test_defs::get::arr<1>); + cc::const_vector vi22(test_defs::get::arr<2>); + cc::const_vector vi13(test_defs::get::arr<1>); + cc::const_vector vi23(test_defs::get::arr<2>); + decltype(vi11) vi1; + decltype(vi21) vi2; + cc::const_vector::capacity<1>()> vi3; + cc::const_vector::capacity<2>()> vi4; + cc::const_vector::arr_len<1>() - 1)> too_small_vi1c; + cc::const_vector::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::arr_len<1>()); + ASSERT(vi2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi2, test_defs::get::arr<2>); + ASSERT(vi3.size() == test_defs::get::arr_len<1>()); + ASSERT(vi4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi4, test_defs::get::arr<2>); + + + cc::const_vector vc11(test_defs::get::arr<1>); + cc::const_vector vc21(test_defs::get::arr<2>); + cc::const_vector vc12(test_defs::get::arr<1>); + cc::const_vector vc22(test_defs::get::arr<2>); + cc::const_vector vc13(test_defs::get::arr<1>); + cc::const_vector vc23(test_defs::get::arr<2>); + decltype(vc11) vc1; + decltype(vc21) vc2; + cc::const_vector::capacity<1>()> vc3; + cc::const_vector::capacity<2>()> vc4; + cc::const_vector::arr_len<1>() - 1)> too_small_vc1c; + cc::const_vector::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::arr_len<1>()); + ASSERT(vc2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc2, test_defs::get::arr<2>); + ASSERT(vc3.size() == test_defs::get::arr_len<1>()); + ASSERT(vc4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc4, test_defs::get::arr<2>); + + + cc::const_vector vs11(test_defs::get::arr<1>); + cc::const_vector vs21(test_defs::get::arr<2>); + cc::const_vector vs12(test_defs::get::arr<1>); + cc::const_vector vs22(test_defs::get::arr<2>); + cc::const_vector vs13(test_defs::get::arr<1>); + cc::const_vector vs23(test_defs::get::arr<2>); + decltype(vs11) vs1; + decltype(vs21) vs2; + cc::const_vector::capacity<1>()> vs3; + cc::const_vector::capacity<2>()> vs4; + cc::const_vector::arr_len<1>() - 1)> too_small_vs1c; + cc::const_vector::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::arr_len<1>()); + ASSERT(vs2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs2, test_defs::get::arr<2>); + ASSERT(vs3.size() == test_defs::get::arr_len<1>()); + ASSERT(vs4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs4, test_defs::get::arr<2>); + + + cc::const_vector vo11(test_defs::get::arr<1>); + cc::const_vector vo21(test_defs::get::arr<2>); + cc::const_vector vo12(test_defs::get::arr<1>); + cc::const_vector vo22(test_defs::get::arr<2>); + cc::const_vector vo13(test_defs::get::arr<1>); + cc::const_vector vo23(test_defs::get::arr<2>); + decltype(vo11) vo1; + decltype(vo21) vo2; + cc::const_vector::capacity<1>()> vo3; + cc::const_vector::capacity<2>()> vo4; + cc::const_vector::arr_len<1>() - 1)> too_small_vo1c; + cc::const_vector::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::arr_len<1>()); + ASSERT(vo2.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo2, test_defs::get::arr<2>); + ASSERT(vo3.size() == test_defs::get::arr_len<1>()); + ASSERT(vo4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo4, test_defs::get::arr<2>); + + return TEST_PASS(); + }, EvalFlag::RUNTIME_CONSTEVAL) + ("const_vector::operator=(const value_type (&array)[])", []() constexpr { + + cc::const_vector::arr_len<1>()> vi1; + cc::const_vector::arr_len<2>()> vi2; + cc::const_vector::capacity<1>()> vi3; + cc::const_vector::capacity<2>()> vi4; + cc::const_vector::arr_len<1>() - 1> too_small_vi1; + cc::const_vector::arr_len<2>() - 1> too_small_vi2; + + vi1 = test_defs::get::arr<1>; + vi2 = test_defs::get::arr<2>; + vi3 = test_defs::get::arr<1>; + vi4 = test_defs::get::arr<2>; + + ASSERT_THROWS((too_small_vi1 = test_defs::get::arr<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vi1 = test_defs::get::arr<2>), std::invalid_argument); + + ASSERT(vi1.size() == test_defs::get::arr_len<1>()); + ASSERT(vi2.size() == test_defs::get::arr_len<2>()); + ASSERT(vi3.size() == test_defs::get::arr_len<1>()); + ASSERT(vi4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vi1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi2, test_defs::get::arr<2>); + ASSERT_VEC_ARR_EQ(vi3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vi4, test_defs::get::arr<2>); + + cc::const_vector::arr_len<1>()> vc1; + cc::const_vector::arr_len<2>()> vc2; + cc::const_vector::capacity<1>()> vc3; + cc::const_vector::capacity<2>()> vc4; + cc::const_vector::arr_len<1>() - 1> too_small_vc1; + cc::const_vector::arr_len<2>() - 1> too_small_vc2; + + vc1 = test_defs::get::arr<1>; + vc2 = test_defs::get::arr<2>; + vc3 = test_defs::get::arr<1>; + vc4 = test_defs::get::arr<2>; + + ASSERT_THROWS((too_small_vc1 = test_defs::get::arr<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vc1 = test_defs::get::arr<2>), std::invalid_argument); + + ASSERT(vc1.size() == test_defs::get::arr_len<1>()); + ASSERT(vc2.size() == test_defs::get::arr_len<2>()); + ASSERT(vc3.size() == test_defs::get::arr_len<1>()); + ASSERT(vc4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vc1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc2, test_defs::get::arr<2>); + ASSERT_VEC_ARR_EQ(vc3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vc4, test_defs::get::arr<2>); + + cc::const_vector::arr_len<1>()> vs1; + cc::const_vector::arr_len<2>()> vs2; + cc::const_vector::capacity<1>()> vs3; + cc::const_vector::capacity<2>()> vs4; + cc::const_vector::arr_len<1>() - 1> too_small_vs1; + cc::const_vector::arr_len<2>() - 1> too_small_vs2; + + vs1 = test_defs::get::arr<1>; + vs2 = test_defs::get::arr<2>; + vs3 = test_defs::get::arr<1>; + vs4 = test_defs::get::arr<2>; + + ASSERT_THROWS((too_small_vs1 = test_defs::get::arr<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vs1 = test_defs::get::arr<2>), std::invalid_argument); + + ASSERT(vs1.size() == test_defs::get::arr_len<1>()); + ASSERT(vs2.size() == test_defs::get::arr_len<2>()); + ASSERT(vs3.size() == test_defs::get::arr_len<1>()); + ASSERT(vs4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vs1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs2, test_defs::get::arr<2>); + ASSERT_VEC_ARR_EQ(vs3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vs4, test_defs::get::arr<2>); + + cc::const_vector::arr_len<1>()> vo1; + cc::const_vector::arr_len<2>()> vo2; + cc::const_vector::capacity<1>()> vo3; + cc::const_vector::capacity<2>()> vo4; + cc::const_vector::arr_len<1>() - 1> too_small_vo1; + cc::const_vector::arr_len<2>() - 1> too_small_vo2; + + vo1 = test_defs::get::arr<1>; + vo2 = test_defs::get::arr<2>; + vo3 = test_defs::get::arr<1>; + vo4 = test_defs::get::arr<2>; + + ASSERT_THROWS((too_small_vo1 = test_defs::get::arr<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vo1 = test_defs::get::arr<2>), std::invalid_argument); + + ASSERT(vo1.size() == test_defs::get::arr_len<1>()); + ASSERT(vo2.size() == test_defs::get::arr_len<2>()); + ASSERT(vo3.size() == test_defs::get::arr_len<1>()); + ASSERT(vo4.size() == test_defs::get::arr_len<2>()); + ASSERT_VEC_ARR_EQ(vo1, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo2, test_defs::get::arr<2>); + ASSERT_VEC_ARR_EQ(vo3, test_defs::get::arr<1>); + ASSERT_VEC_ARR_EQ(vo4, test_defs::get::arr<2>); + + return TEST_PASS(); + }, EvalFlag::RUNTIME_CONSTEVAL) + ("const_vector::operator=(std::initializer_list values)", []() constexpr { + + cc::const_vector::il_len<1>()> vi1; + cc::const_vector::il_len<2>()> vi2; + cc::const_vector::capacity<1>()> vi3; + cc::const_vector::capacity<2>()> vi4; + cc::const_vector::il_len<1>() - 1> too_small_vi1; + cc::const_vector::il_len<2>() - 1> too_small_vi2; + + OPERATOR_EQ_IL(vi1, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vi2, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + OPERATOR_EQ_IL(vi3, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vi4, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + + ASSERT_THROWS((too_small_vi1 = test_defs::get::i_list<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vi1 = test_defs::get::i_list<2>), std::invalid_argument); + + ASSERT(vi1.size() == test_defs::get::il_len<1>()); + ASSERT(vi2.size() == test_defs::get::il_len<2>()); + ASSERT(vi3.size() == test_defs::get::il_len<1>()); + ASSERT(vi4.size() == test_defs::get::il_len<2>()); + ASSERT_VEC_ARR_EQ(vi1, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vi2, test_defs::get::i_list<2>); + ASSERT_VEC_ARR_EQ(vi3, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vi4, test_defs::get::i_list<2>); + + cc::const_vector::il_len<1>()> vc1; + cc::const_vector::il_len<2>()> vc2; + cc::const_vector::capacity<1>()> vc3; + cc::const_vector::capacity<2>()> vc4; + cc::const_vector::il_len<1>() - 1> too_small_vc1; + cc::const_vector::il_len<2>() - 1> too_small_vc2; + + OPERATOR_EQ_IL(vc1, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vc2, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + OPERATOR_EQ_IL(vc3, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vc4, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + + ASSERT_THROWS((too_small_vc1 = test_defs::get::i_list<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vc1 = test_defs::get::i_list<2>), std::invalid_argument); + + ASSERT(vc1.size() == test_defs::get::il_len<1>()); + ASSERT(vc2.size() == test_defs::get::il_len<2>()); + ASSERT(vc3.size() == test_defs::get::il_len<1>()); + ASSERT(vc4.size() == test_defs::get::il_len<2>()); + ASSERT_VEC_ARR_EQ(vc1, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vc2, test_defs::get::i_list<2>); + ASSERT_VEC_ARR_EQ(vc3, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vc4, test_defs::get::i_list<2>); + + cc::const_vector::il_len<1>()> vs1; + cc::const_vector::il_len<2>()> vs2; + cc::const_vector::capacity<1>()> vs3; + cc::const_vector::capacity<2>()> vs4; + cc::const_vector::il_len<1>() - 1> too_small_vs1; + cc::const_vector::il_len<2>() - 1> too_small_vs2; + + OPERATOR_EQ_IL(vs1, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vs2, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + OPERATOR_EQ_IL(vs3, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vs4, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + + ASSERT_THROWS((too_small_vs1 = test_defs::get::i_list<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vs1 = test_defs::get::i_list<2>), std::invalid_argument); + + ASSERT(vs1.size() == test_defs::get::il_len<1>()); + ASSERT(vs2.size() == test_defs::get::il_len<2>()); + ASSERT(vs3.size() == test_defs::get::il_len<1>()); + ASSERT(vs4.size() == test_defs::get::il_len<2>()); + ASSERT_VEC_ARR_EQ(vs1, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vs2, test_defs::get::i_list<2>); + ASSERT_VEC_ARR_EQ(vs3, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vs4, test_defs::get::i_list<2>); + + cc::const_vector::il_len<1>()> vo1; + cc::const_vector::il_len<2>()> vo2; + cc::const_vector::capacity<1>()> vo3; + cc::const_vector::capacity<2>()> vo4; + cc::const_vector::il_len<1>() - 1> too_small_vo1; + cc::const_vector::il_len<2>() - 1> too_small_vo2; + + OPERATOR_EQ_IL(vo1, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vo2, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + OPERATOR_EQ_IL(vo3, test_defs::get::i_list<1>, test_defs::get::il_len<1>()); + OPERATOR_EQ_IL(vo4, test_defs::get::i_list<2>, test_defs::get::il_len<2>()); + + ASSERT_THROWS((too_small_vo1 = test_defs::get::i_list<1>), std::invalid_argument); + ASSERT_THROWS((too_small_vo1 = test_defs::get::i_list<2>), std::invalid_argument); + + ASSERT(vo1.size() == test_defs::get::il_len<1>()); + ASSERT(vo2.size() == test_defs::get::il_len<2>()); + ASSERT(vo3.size() == test_defs::get::il_len<1>()); + ASSERT(vo4.size() == test_defs::get::il_len<2>()); + ASSERT_VEC_ARR_EQ(vo1, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vo2, test_defs::get::i_list<2>); + ASSERT_VEC_ARR_EQ(vo3, test_defs::get::i_list<1>); + ASSERT_VEC_ARR_EQ(vo4, test_defs::get::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(); -} \ No newline at end of file +} +#pragma clang diagnostic pop \ No newline at end of file