diff --git a/include/etl/private/variant_variadic.h b/include/etl/private/variant_variadic.h index 28a94f12..498cdf63 100644 --- a/include/etl/private/variant_variadic.h +++ b/include/etl/private/variant_variadic.h @@ -1018,41 +1018,41 @@ namespace etl { switch (index()) { - case 0: visitor.visit(etl::get<0>(*this)); break; - case 1: visitor.visit(etl::get<1>(*this)); break; - case 2: visitor.visit(etl::get<2>(*this)); break; - case 3: visitor.visit(etl::get<3>(*this)); break; - case 4: visitor.visit(etl::get<4>(*this)); break; - case 5: visitor.visit(etl::get<5>(*this)); break; - case 6: visitor.visit(etl::get<6>(*this)); break; - case 7: visitor.visit(etl::get<7>(*this)); break; + case 0: { auto arg = etl::get<0>(*this); visitor.visit(arg); break; } + case 1: { auto arg = etl::get<1>(*this); visitor.visit(arg); break; } + case 2: { auto arg = etl::get<2>(*this); visitor.visit(arg); break; } + case 3: { auto arg = etl::get<3>(*this); visitor.visit(arg); break; } + case 4: { auto arg = etl::get<4>(*this); visitor.visit(arg); break; } + case 5: { auto arg = etl::get<5>(*this); visitor.visit(arg); break; } + case 6: { auto arg = etl::get<6>(*this); visitor.visit(arg); break; } + case 7: { auto arg = etl::get<7>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES) - case 8: visitor.visit(etl::get<8>(*this)); break; - case 9: visitor.visit(etl::get<9>(*this)); break; - case 10: visitor.visit(etl::get<10>(*this)); break; - case 11: visitor.visit(etl::get<11>(*this)); break; - case 12: visitor.visit(etl::get<12>(*this)); break; - case 13: visitor.visit(etl::get<13>(*this)); break; - case 14: visitor.visit(etl::get<14>(*this)); break; - case 15: visitor.visit(etl::get<15>(*this)); break; + case 8: { auto arg = etl::get<8>(*this); visitor.visit(arg); break; } + case 9: { auto arg = etl::get<9>(*this); visitor.visit(arg); break; } + case 10: { auto arg = etl::get<10>(*this); visitor.visit(arg); break; } + case 11: { auto arg = etl::get<11>(*this); visitor.visit(arg); break; } + case 12: { auto arg = etl::get<12>(*this); visitor.visit(arg); break; } + case 13: { auto arg = etl::get<13>(*this); visitor.visit(arg); break; } + case 14: { auto arg = etl::get<14>(*this); visitor.visit(arg); break; } + case 15: { auto arg = etl::get<15>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES) - case 16: visitor.visit(etl::get<16>(*this)); break; - case 17: visitor.visit(etl::get<17>(*this)); break; - case 18: visitor.visit(etl::get<18>(*this)); break; - case 19: visitor.visit(etl::get<19>(*this)); break; - case 20: visitor.visit(etl::get<20>(*this)); break; - case 21: visitor.visit(etl::get<21>(*this)); break; - case 22: visitor.visit(etl::get<22>(*this)); break; - case 23: visitor.visit(etl::get<23>(*this)); break; + case 16: { auto arg = etl::get<16>(*this); visitor.visit(arg); break; } + case 17: { auto arg = etl::get<17>(*this); visitor.visit(arg); break; } + case 18: { auto arg = etl::get<18>(*this); visitor.visit(arg); break; } + case 19: { auto arg = etl::get<19>(*this); visitor.visit(arg); break; } + case 20: { auto arg = etl::get<20>(*this); visitor.visit(arg); break; } + case 21: { auto arg = etl::get<21>(*this); visitor.visit(arg); break; } + case 22: { auto arg = etl::get<22>(*this); visitor.visit(arg); break; } + case 23: { auto arg = etl::get<23>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES) - case 24: visitor.visit(etl::get<24>(*this)); break; - case 25: visitor.visit(etl::get<25>(*this)); break; - case 26: visitor.visit(etl::get<26>(*this)); break; - case 27: visitor.visit(etl::get<27>(*this)); break; - case 28: visitor.visit(etl::get<28>(*this)); break; - case 29: visitor.visit(etl::get<29>(*this)); break; - case 30: visitor.visit(etl::get<30>(*this)); break; - case 31: visitor.visit(etl::get<31>(*this)); break; + case 24: { auto arg = etl::get<24>(*this); visitor.visit(arg); break; } + case 25: { auto arg = etl::get<25>(*this); visitor.visit(arg); break; } + case 26: { auto arg = etl::get<26>(*this); visitor.visit(arg); break; } + case 27: { auto arg = etl::get<27>(*this); visitor.visit(arg); break; } + case 28: { auto arg = etl::get<28>(*this); visitor.visit(arg); break; } + case 29: { auto arg = etl::get<29>(*this); visitor.visit(arg); break; } + case 30: { auto arg = etl::get<30>(*this); visitor.visit(arg); break; } + case 31: { auto arg = etl::get<31>(*this); visitor.visit(arg); break; } #endif #endif #endif @@ -1068,41 +1068,41 @@ namespace etl { switch (index()) { - case 0: visitor.visit(etl::get<0>(*this)); break; - case 1: visitor.visit(etl::get<1>(*this)); break; - case 2: visitor.visit(etl::get<2>(*this)); break; - case 3: visitor.visit(etl::get<3>(*this)); break; - case 4: visitor.visit(etl::get<4>(*this)); break; - case 5: visitor.visit(etl::get<5>(*this)); break; - case 6: visitor.visit(etl::get<6>(*this)); break; - case 7: visitor.visit(etl::get<7>(*this)); break; + case 0: { auto arg = etl::get<0>(*this); visitor.visit(arg); break; } + case 1: { auto arg = etl::get<1>(*this); visitor.visit(arg); break; } + case 2: { auto arg = etl::get<2>(*this); visitor.visit(arg); break; } + case 3: { auto arg = etl::get<3>(*this); visitor.visit(arg); break; } + case 4: { auto arg = etl::get<4>(*this); visitor.visit(arg); break; } + case 5: { auto arg = etl::get<5>(*this); visitor.visit(arg); break; } + case 6: { auto arg = etl::get<6>(*this); visitor.visit(arg); break; } + case 7: { auto arg = etl::get<7>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES) - case 8: visitor.visit(etl::get<8>(*this)); break; - case 9: visitor.visit(etl::get<9>(*this)); break; - case 10: visitor.visit(etl::get<10>(*this)); break; - case 11: visitor.visit(etl::get<11>(*this)); break; - case 12: visitor.visit(etl::get<12>(*this)); break; - case 13: visitor.visit(etl::get<13>(*this)); break; - case 14: visitor.visit(etl::get<14>(*this)); break; - case 15: visitor.visit(etl::get<15>(*this)); break; + case 8: { auto arg = etl::get<8>(*this); visitor.visit(arg); break; } + case 9: { auto arg = etl::get<9>(*this); visitor.visit(arg); break; } + case 10: { auto arg = etl::get<10>(*this); visitor.visit(arg); break; } + case 11: { auto arg = etl::get<11>(*this); visitor.visit(arg); break; } + case 12: { auto arg = etl::get<12>(*this); visitor.visit(arg); break; } + case 13: { auto arg = etl::get<13>(*this); visitor.visit(arg); break; } + case 14: { auto arg = etl::get<14>(*this); visitor.visit(arg); break; } + case 15: { auto arg = etl::get<15>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES) - case 16: visitor.visit(etl::get<16>(*this)); break; - case 17: visitor.visit(etl::get<17>(*this)); break; - case 18: visitor.visit(etl::get<18>(*this)); break; - case 19: visitor.visit(etl::get<19>(*this)); break; - case 20: visitor.visit(etl::get<20>(*this)); break; - case 21: visitor.visit(etl::get<21>(*this)); break; - case 22: visitor.visit(etl::get<22>(*this)); break; - case 23: visitor.visit(etl::get<23>(*this)); break; + case 16: { auto arg = etl::get<16>(*this); visitor.visit(arg); break; } + case 17: { auto arg = etl::get<17>(*this); visitor.visit(arg); break; } + case 18: { auto arg = etl::get<18>(*this); visitor.visit(arg); break; } + case 19: { auto arg = etl::get<19>(*this); visitor.visit(arg); break; } + case 20: { auto arg = etl::get<20>(*this); visitor.visit(arg); break; } + case 21: { auto arg = etl::get<21>(*this); visitor.visit(arg); break; } + case 22: { auto arg = etl::get<22>(*this); visitor.visit(arg); break; } + case 23: { auto arg = etl::get<23>(*this); visitor.visit(arg); break; } #if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES) - case 24: visitor.visit(etl::get<24>(*this)); break; - case 25: visitor.visit(etl::get<25>(*this)); break; - case 26: visitor.visit(etl::get<26>(*this)); break; - case 27: visitor.visit(etl::get<27>(*this)); break; - case 28: visitor.visit(etl::get<28>(*this)); break; - case 29: visitor.visit(etl::get<29>(*this)); break; - case 30: visitor.visit(etl::get<30>(*this)); break; - case 31: visitor.visit(etl::get<31>(*this)); break; + case 24: { auto arg = etl::get<24>(*this); visitor.visit(arg); break; } + case 25: { auto arg = etl::get<25>(*this); visitor.visit(arg); break; } + case 26: { auto arg = etl::get<26>(*this); visitor.visit(arg); break; } + case 27: { auto arg = etl::get<27>(*this); visitor.visit(arg); break; } + case 28: { auto arg = etl::get<28>(*this); visitor.visit(arg); break; } + case 29: { auto arg = etl::get<29>(*this); visitor.visit(arg); break; } + case 30: { auto arg = etl::get<30>(*this); visitor.visit(arg); break; } + case 31: { auto arg = etl::get<31>(*this); visitor.visit(arg); break; } #endif #endif #endif diff --git a/test/test_variant_variadic.cpp b/test/test_variant_variadic.cpp index 8ceb50bc..d096f21e 100644 --- a/test/test_variant_variadic.cpp +++ b/test/test_variant_variadic.cpp @@ -32,20 +32,22 @@ SOFTWARE. #include "etl/visitor.h" #include "etl/overload.h" -#if ETL_USING_CPP17 +#if ETL_USING_CPP14 #include #include #include #include #include -#include + +#if ETL_USING_CPP17 + #include +#endif namespace { // Test variant_etl types. using test_variant_etl_3 = etl::variant; - using test_variant_std_3 = std::variant; struct D1 { @@ -480,6 +482,7 @@ namespace //************************************************************************* TEST(test_construct_multiple_parameters_by_type) { +#if ETL_USING_CPP17 test_variant_emplace variant_etl1(etl::in_place_type, "1"); CHECK(etl::holds_alternative(variant_etl1)); CHECK_EQUAL(D1("1"), etl::get(variant_etl1)); @@ -495,12 +498,30 @@ namespace test_variant_emplace variant_etl4(etl::in_place_type, "1", "2", "3", "4"); CHECK(etl::holds_alternative(variant_etl4)); CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get(variant_etl4)); +#else + test_variant_emplace variant_etl1(etl::in_place_type_t{}, "1"); + CHECK(etl::holds_alternative(variant_etl1)); + CHECK_EQUAL(D1("1"), etl::get(variant_etl1)); + + test_variant_emplace variant_etl2(etl::in_place_type_t{}, "1", "2"); + CHECK(etl::holds_alternative(variant_etl2)); + CHECK_EQUAL(D2("1", "2"), etl::get(variant_etl2)); + + test_variant_emplace variant_etl3(etl::in_place_type_t{}, "1", "2", "3"); + CHECK(etl::holds_alternative(variant_etl3)); + CHECK_EQUAL(D3("1", "2", "3"), etl::get(variant_etl3)); + + test_variant_emplace variant_etl4(etl::in_place_type_t{}, "1", "2", "3", "4"); + CHECK(etl::holds_alternative(variant_etl4)); + CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get(variant_etl4)); +#endif } //************************************************************************* TEST(test_construct_multiple_parameters_by_index) { - test_variant_emplace variant_etl1(etl::in_place_index<1U>, "1"); +#if ETL_USING_CPP17 + test_variant_emplace variant_etl1(etl::in_place_index<1>, "1"); CHECK(etl::holds_alternative(variant_etl1)); CHECK_EQUAL(D1("1"), etl::get(variant_etl1)); @@ -512,12 +533,29 @@ namespace CHECK(etl::holds_alternative(variant_etl3)); CHECK_EQUAL(D3("1", "2", "3"), etl::get(variant_etl3)); - test_variant_emplace variant_etl4(etl::in_place_index<4U>, "1", "2", "3", "4"); + test_variant_emplace variant_etl4(etl::in_place_index<4>, "1", "2", "3", "4"); CHECK(etl::holds_alternative(variant_etl4)); CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get(variant_etl4)); +#else + test_variant_emplace variant_etl1(etl::in_place_index_t<1>{}, "1"); + CHECK(etl::holds_alternative(variant_etl1)); + CHECK_EQUAL(D1("1"), etl::get(variant_etl1)); + + test_variant_emplace variant_etl2(etl::in_place_index_t<2>{}, "1", "2"); + CHECK(etl::holds_alternative(variant_etl2)); + CHECK_EQUAL(D2("1", "2"), etl::get(variant_etl2)); + + test_variant_emplace variant_etl3(etl::in_place_index_t<3>{}, "1", "2", "3"); + CHECK(etl::holds_alternative(variant_etl3)); + CHECK_EQUAL(D3("1", "2", "3"), etl::get(variant_etl3)); + + test_variant_emplace variant_etl4(etl::in_place_index_t<4>{}, "1", "2", "3", "4"); + CHECK(etl::holds_alternative(variant_etl4)); + CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get(variant_etl4)); +#endif } -#if ETL_USING_STL +#if ETL_HAS_INITIALIZER_LIST //************************************************************************* TEST(test_construct_with_initializer_list_by_type) { @@ -806,21 +844,67 @@ namespace test_variant_etl_3 variant_etl; variant_etl = char(1); - //variant_etl.accept_visitor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(1, visitor.result_c); variant_etl = int(2); - //variant_etl.accept_visitor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(2, visitor.result_i); variant_etl = std::string("3"); - //variant_etl.accept_visitor(visitor); variant_etl.accept(visitor); CHECK_EQUAL("3", visitor.result_s); } + //************************************************************************* + TEST(test_variant_accept_visitor_depracated) + { + struct Visitor : public etl::visitor + { + Visitor() + : result_c(0) + , result_i(0) + , result_s("") + { + } + + void visit(char& c) + { + result_c = c; + } + + void visit(int& i) + { + result_i = i; + } + + void visit(std::string& s) + { + result_s = s; + } + + char result_c; + int result_i; + std::string result_s; + }; + + Visitor visitor; + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + variant_etl.accept_visitor(visitor); + CHECK_EQUAL(1, visitor.result_c); + + variant_etl = int(2); + variant_etl.accept_visitor(visitor); + CHECK_EQUAL(2, visitor.result_i); + + variant_etl = std::string("3"); + variant_etl.accept_visitor(visitor); + CHECK_EQUAL("3", visitor.result_s); + } + //************************************************************************* TEST(test_const_variant_accept_visitor) { @@ -859,23 +943,72 @@ namespace variant_etl = char(1); const test_variant_etl_3 const_variant_etl1(variant_etl); - const_variant_etl1.accept_visitor(visitor); - //const_variant_etl1.accept(visitor); + const_variant_etl1.accept(visitor); CHECK_EQUAL(1, visitor.result_c); variant_etl = int(2); const test_variant_etl_3 const_variant_etl2(variant_etl); - //const_variant_etl2.accept_visitor(visitor); const_variant_etl2.accept(visitor); CHECK_EQUAL(2, visitor.result_i); variant_etl = std::string("3"); const test_variant_etl_3 const_variant_etl3(variant_etl); - //const_variant_etl3.accept_visitor(visitor); const_variant_etl3.accept(visitor); CHECK_EQUAL("3", visitor.result_s); } + //************************************************************************* + TEST(test_const_variant_accept_visitor_deprecated) + { + struct Visitor : public etl::visitor + { + Visitor() + : result_c(0) + , result_i(0) + , result_s("") + { + } + + void visit(char& c) + { + result_c = c; + } + + void visit(int& i) + { + result_i = i; + } + + void visit(std::string& s) + { + result_s = s; + } + + char result_c; + int result_i; + std::string result_s; + }; + + Visitor visitor; + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + const test_variant_etl_3 const_variant_etl1(variant_etl); + const_variant_etl1.accept(visitor); + CHECK_EQUAL(1, visitor.result_c); + + variant_etl = int(2); + const test_variant_etl_3 const_variant_etl2(variant_etl); + const_variant_etl2.accept_visitor(visitor); + CHECK_EQUAL(2, visitor.result_i); + + variant_etl = std::string("3"); + const test_variant_etl_3 const_variant_etl3(variant_etl); + const_variant_etl3.accept_visitor(visitor); + CHECK_EQUAL("3", visitor.result_s); + } + //************************************************************************* TEST(test_variant_accept_functor_with_functor_class) { @@ -913,21 +1046,67 @@ namespace test_variant_etl_3 variant_etl; variant_etl = char(1); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(1, visitor.result_c); variant_etl = int(2); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(2, visitor.result_i); variant_etl = std::string("3"); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL("3", visitor.result_s); } + //************************************************************************* + TEST(test_variant_accept_functor_with_functor_class_deprecated) + { + struct Visitor + { + Visitor() + : result_c(0) + , result_i(0) + , result_s("") + { + } + + void operator()(char c) + { + result_c = c; + } + + void operator()(int i) + { + result_i = i; + } + + void operator()(const std::string& s) + { + result_s = s; + } + + char result_c; + int result_i; + std::string result_s; + }; + + Visitor visitor; + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + variant_etl.accept_functor(visitor); + CHECK_EQUAL(1, visitor.result_c); + + variant_etl = int(2); + variant_etl.accept_functor(visitor); + CHECK_EQUAL(2, visitor.result_i); + + variant_etl = std::string("3"); + variant_etl.accept_functor(visitor); + CHECK_EQUAL("3", visitor.result_s); + } + //************************************************************************* TEST(test_const_variant_accept_functor_with_functor_class) { @@ -966,24 +1145,74 @@ namespace variant_etl = char(1); const test_variant_etl_3 const_variant_etl1(variant_etl); - //const_variant_etl1.accept_functor(visitor); const_variant_etl1.accept(visitor); CHECK_EQUAL(1, visitor.result_c); variant_etl = int(2); const test_variant_etl_3 const_variant_etl2(variant_etl); - //const_variant_etl2.accept_functor(visitor); const_variant_etl2.accept(visitor); CHECK_EQUAL(2, visitor.result_i); variant_etl = std::string("3"); const test_variant_etl_3 const_variant_etl3(variant_etl); - //const_variant_etl3.accept_functor(visitor); const_variant_etl3.accept(visitor); CHECK_EQUAL("3", visitor.result_s); } //************************************************************************* + TEST(test_const_variant_accept_functor_with_functor_class_deprecated) + { + struct Visitor + { + Visitor() + : result_c(0) + , result_i(0) + , result_s("") + { + } + + void operator()(char c) + { + result_c = c; + } + + void operator()(int i) + { + result_i = i; + } + + void operator()(const std::string& s) + { + result_s = s; + } + + char result_c; + int result_i; + std::string result_s; + }; + + Visitor visitor; + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + const test_variant_etl_3 const_variant_etl1(variant_etl); + const_variant_etl1.accept_functor(visitor); + CHECK_EQUAL(1, visitor.result_c); + + variant_etl = int(2); + const test_variant_etl_3 const_variant_etl2(variant_etl); + const_variant_etl2.accept_functor(visitor); + CHECK_EQUAL(2, visitor.result_i); + + variant_etl = std::string("3"); + const test_variant_etl_3 const_variant_etl3(variant_etl); + const_variant_etl3.accept_functor(visitor); + CHECK_EQUAL("3", visitor.result_s); + } + + //************************************************************************* +#if ETL_USING_CPP17 TEST(test_variant_accept_functor_with_overload) { char result_c; @@ -997,21 +1226,44 @@ namespace test_variant_etl_3 variant_etl; variant_etl = char(1); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(1, result_c); variant_etl = int(2); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL(2, result_i); variant_etl = std::string("3"); - //variant_etl.accept_functor(visitor); variant_etl.accept(visitor); CHECK_EQUAL("3", result_s); } + //************************************************************************* + TEST(test_variant_accept_functor_with_overload_deprecated) + { + char result_c; + int result_i; + std::string result_s; + + auto visitor = etl::make_overload([&result_c](char) { result_c = 1; }, + [&result_i](int) { result_i = 2; }, + [&result_s](const std::string&) { result_s = "3"; }); + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + variant_etl.accept_functor(visitor); + CHECK_EQUAL(1, result_c); + + variant_etl = int(2); + variant_etl.accept_functor(visitor); + CHECK_EQUAL(2, result_i); + + variant_etl = std::string("3"); + variant_etl.accept_functor(visitor); + CHECK_EQUAL("3", result_s); + } + //************************************************************************* TEST(test_const_variant_accept_functor_with_overload) { @@ -1027,23 +1279,50 @@ namespace variant_etl = char(1); const test_variant_etl_3 const_variant_etl1(variant_etl); - //const_variant_etl1.accept_functor(visitor); const_variant_etl1.accept(visitor); CHECK_EQUAL(1, result_c); variant_etl = int(2); const test_variant_etl_3 const_variant_etl2(variant_etl); - //const_variant_etl2.accept_functor(visitor); const_variant_etl2.accept(visitor); CHECK_EQUAL(2, result_i); variant_etl = std::string("3"); const test_variant_etl_3 const_variant_etl3(variant_etl); - //const_variant_etl3.accept_functor(visitor); const_variant_etl3.accept(visitor); CHECK_EQUAL("3", result_s); } + //************************************************************************* + TEST(test_const_variant_accept_functor_with_overload_deprecated) + { + char result_c; + int result_i; + std::string result_s; + + auto visitor = etl::make_overload([&result_c](char) { result_c = 1; }, + [&result_i](int) { result_i = 2; }, + [&result_s](const std::string&) { result_s = "3"; }); + + test_variant_etl_3 variant_etl; + + variant_etl = char(1); + const test_variant_etl_3 const_variant_etl1(variant_etl); + const_variant_etl1.accept_functor(visitor); + CHECK_EQUAL(1, result_c); + + variant_etl = int(2); + const test_variant_etl_3 const_variant_etl2(variant_etl); + const_variant_etl2.accept_functor(visitor); + CHECK_EQUAL(2, result_i); + + variant_etl = std::string("3"); + const test_variant_etl_3 const_variant_etl3(variant_etl); + const_variant_etl3.accept_functor(visitor); + CHECK_EQUAL("3", result_s); + } +#endif + //************************************************************************* TEST(test_get_if_index) { @@ -1091,9 +1370,14 @@ namespace { test_variant_etl_3 variant_etl; +#if ETL_USING_CPP17 CHECK_EQUAL(3U, etl::variant_size_v); +#else + CHECK_EQUAL(3U, etl::variant_size::value); +#endif } +#if ETL_USING_CPP17 //************************************************************************* TEST(test_compare_etl_and_stl_variant_with_moveable_type) { @@ -1280,6 +1564,7 @@ namespace CHECK_EQUAL(value_vcrr_std.moved_to, value_vcrr_etl.moved_to); CHECK_EQUAL(value_vcrr_std.copied_to, value_vcrr_etl.copied_to); } +#endif //************************************************************************* TEST(test_get_if_by_type) @@ -1533,6 +1818,7 @@ namespace CHECK_EQUAL(false, variant_was_signed); } +#if ETL_USING_CPP17 //************************************************************************* TEST(test_variant_visit_with_overload) { @@ -1603,6 +1889,7 @@ namespace CHECK_EQUAL(std::string("TypeD"), result); } +#endif }; }