diff --git a/include/etl/array.h b/include/etl/array.h index 1f1195db..dad17988 100644 --- a/include/etl/array.h +++ b/include/etl/array.h @@ -83,7 +83,7 @@ namespace etl ///\ingroup array /// A replacement for std::array if you haven't got C++0x11. //*************************************************************************** - template + template class array { private: @@ -92,10 +92,7 @@ namespace etl public: - enum - { - SIZE = SIZE_ - }; + static ETL_CONSTANT size_t SIZE = SIZE_; typedef T value_type; typedef size_t size_type; @@ -563,6 +560,9 @@ namespace etl } }; + template + ETL_CONSTANT size_t array::SIZE; + //************************************************************************* /// Template deduction guides. //************************************************************************* diff --git a/include/etl/fsm.h b/include/etl/fsm.h index 0f2eb368..d06e2f6e 100644 --- a/include/etl/fsm.h +++ b/include/etl/fsm.h @@ -81,10 +81,10 @@ namespace etl typedef typename etl::larger_type::type fsm_internal_id_t; #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above - template + template class fsm_state; #else - template ::max; + // Pass this when this event also needs to be passed to the parent. static ETL_CONSTANT fsm_state_id_t Pass_To_Parent = No_State_Change - 1U; }; @@ -201,11 +202,14 @@ namespace etl friend class etl::fsm; friend class etl::hfsm; + using private_fsm::ifsm_state_helper<>::No_State_Change; + using private_fsm::ifsm_state_helper<>::Pass_To_Parent; + #if ETL_USING_CPP17 && !defined(ETL_FSM_FORCE_CPP03_IMPLEMENTATION) // For C++17 and above - template + template friend class fsm_state; #else - template + template class fsm_state : public ifsm_state { public: @@ -589,7 +593,7 @@ namespace etl //*************************************************************************** // The definition for all 16 message types. //*************************************************************************** - template @@ -903,7 +907,7 @@ namespace etl //*************************************************************************** // Specialisation for 11 message types. //*************************************************************************** - template @@ -962,7 +966,7 @@ namespace etl //*************************************************************************** // Specialisation for 10 message types. //*************************************************************************** - template @@ -1020,7 +1024,7 @@ namespace etl //*************************************************************************** // Specialisation for 9 message types. //*************************************************************************** - template @@ -1077,7 +1081,7 @@ namespace etl //*************************************************************************** // Specialisation for 8 message types. //*************************************************************************** - template class fsm_state : public ifsm_state @@ -1132,7 +1136,7 @@ namespace etl //*************************************************************************** // Specialisation for 7 message types. //*************************************************************************** - template class fsm_state : public ifsm_state @@ -1186,7 +1190,7 @@ namespace etl //*************************************************************************** // Specialisation for 6 message types. //*************************************************************************** - template class fsm_state : public ifsm_state @@ -1239,7 +1243,7 @@ namespace etl //*************************************************************************** // Specialisation for 5 message types. //*************************************************************************** - template class fsm_state : public ifsm_state @@ -1291,7 +1295,7 @@ namespace etl //*************************************************************************** // Specialisation for 4 message types. //*************************************************************************** - template class fsm_state : public ifsm_state { @@ -1341,7 +1345,7 @@ namespace etl //*************************************************************************** // Specialisation for 3 message types. //*************************************************************************** - template class fsm_state : public ifsm_state { @@ -1390,7 +1394,7 @@ namespace etl //*************************************************************************** // Specialisation for 2 message types. //*************************************************************************** - template class fsm_state : public ifsm_state { @@ -1438,7 +1442,7 @@ namespace etl //*************************************************************************** // Specialisation for 1 message type. //*************************************************************************** - template class fsm_state : public ifsm_state { @@ -1485,7 +1489,7 @@ namespace etl //*************************************************************************** // Specialisation for 0 message types. //*************************************************************************** - template + template class fsm_state : public ifsm_state { public: diff --git a/include/etl/generators/message_packet_generator.h b/include/etl/generators/message_packet_generator.h index 8a9bf0e0..38406908 100644 --- a/include/etl/generators/message_packet_generator.h +++ b/include/etl/generators/message_packet_generator.h @@ -365,11 +365,9 @@ namespace etl ################################################ def generate_accepts_return_compile_time_TMessage(n): - cog.outl(" ETL_CONSTANT etl::message_id_t id = TMessage::ID;") - cog.outl("") cog.out(" return") for i in range(1, n + 1): - cog.out(" T%d::ID == id" % i) + cog.out(" T%d::ID == TMessage::ID" % i) if i < n: cog.out(" ||") if i % 4 == 0: diff --git a/include/etl/generators/smallest_generator.h b/include/etl/generators/smallest_generator.h index 771d4111..8879b96a 100644 --- a/include/etl/generators/smallest_generator.h +++ b/include/etl/generators/smallest_generator.h @@ -382,17 +382,17 @@ namespace etl private: // Determines the index of the best unsigned type for the required value. - static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + - ((VALUE > UINT16_MAX) ? 1 : 0) + - ((VALUE > UINT32_MAX) ? 1 : 0); + static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + + ((VALUE > UINT16_MAX) ? 1 : 0) + + ((VALUE > UINT32_MAX) ? 1 : 0); public: typedef typename private_smallest::best_fit_uint_type::type type; }; - template - ETL_CONSTANT int smallest_uint_for_value::TYPE_INDEX; + template + ETL_CONSTANT int smallest_uint_for_value::TYPE_INDEX; #if ETL_USING_CPP11 template @@ -405,23 +405,23 @@ namespace etl /// Defines 'type' which is the type of the smallest signed integer. ///\ingroup smallest //*************************************************************************** - template + template struct smallest_int_for_value { private: // Determines the index of the best signed type for the required value. static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) + - (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + - (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0); + (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + + (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0); public: typedef typename private_smallest::best_fit_int_type::type type; }; - template - ETL_CONSTANT int smallest_int_for_value::TYPE_INDEX; + template + ETL_CONSTANT int smallest_int_for_value::TYPE_INDEX; #if ETL_USING_CPP11 template diff --git a/include/etl/generators/type_traits_generator.h b/include/etl/generators/type_traits_generator.h index bcaa8e54..8dfce084 100644 --- a/include/etl/generators/type_traits_generator.h +++ b/include/etl/generators/type_traits_generator.h @@ -114,7 +114,7 @@ namespace etl typedef integral_constant false_type; typedef integral_constant true_type; - template + template const T integral_constant::value; #if ETL_USING_CPP17 @@ -841,11 +841,6 @@ typedef integral_constant true_type; inline constexpr T integral_constant_v = std::integral_constant::value; #endif -#if ETL_USING_CPP17 - template - inline constexpr T integral_constant_v = std::integral_constant::value; -#endif - #if ETL_USING_CPP17 template using bool_constant = std::bool_constant; @@ -864,9 +859,7 @@ typedef integral_constant true_type; ///\ingroup type_traits #if ETL_USING_CPP17 template - struct negation : std::negation - { - }; + using negation = std::negation; #else template struct negation : etl::bool_constant diff --git a/include/etl/message.h b/include/etl/message.h index aeebb35b..93e2ddad 100644 --- a/include/etl/message.h +++ b/include/etl/message.h @@ -86,16 +86,16 @@ namespace etl public: - enum - { - ID = ID_ - }; + static ETL_CONSTANT etl::message_id_t ID = ID_; ETL_NODISCARD etl::message_id_t get_message_id() const ETL_NOEXCEPT ETL_OVERRIDE { return ID; } }; + + template + ETL_CONSTANT etl::message_id_t message::ID; } #endif diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h index d5130974..e40640bf 100644 --- a/include/etl/message_packet.h +++ b/include/etl/message_packet.h @@ -526,12 +526,10 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || - T13::ID == id || T14::ID == id || T15::ID == id || T16::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID || + T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID || T16::ID == TMessage::ID; } enum @@ -819,12 +817,10 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || - T13::ID == id || T14::ID == id || T15::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID || + T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID; } enum @@ -1110,12 +1106,10 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || - T13::ID == id || T14::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID || + T13::ID == TMessage::ID || T14::ID == TMessage::ID; } enum @@ -1399,12 +1393,10 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || - T13::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID || + T13::ID == TMessage::ID; } enum @@ -1683,11 +1675,9 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID; } enum @@ -1964,11 +1954,9 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id || T11::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID; } enum @@ -2243,11 +2231,9 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id || T10::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID || T10::ID == TMessage::ID; } enum @@ -2520,11 +2506,9 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || - T9::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID || + T9::ID == TMessage::ID; } enum @@ -2792,10 +2776,8 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID; } enum @@ -3061,10 +3043,8 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id || T7::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID; } enum @@ -3328,10 +3308,8 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id || T6::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID || T6::ID == TMessage::ID; } enum @@ -3593,10 +3571,8 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || - T5::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID || + T5::ID == TMessage::ID; } enum @@ -3853,9 +3829,7 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID; } enum @@ -4110,9 +4084,7 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id || T3::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID; } enum @@ -4365,9 +4337,7 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id || T2::ID == id; + return T1::ID == TMessage::ID || T2::ID == TMessage::ID; } enum @@ -4618,9 +4588,7 @@ namespace etl typename etl::enable_if::value, bool>::type accepts() { - ETL_CONSTANT etl::message_id_t id = TMessage::ID; - - return T1::ID == id; + return T1::ID == TMessage::ID; } enum diff --git a/include/etl/numeric.h b/include/etl/numeric.h index c40d7be2..dd55bc91 100644 --- a/include/etl/numeric.h +++ b/include/etl/numeric.h @@ -133,9 +133,9 @@ namespace etl /// For pointers. //*************************************************************************** template - ETL_CONSTEXPR typename etl::enable_if::value&& - !etl::is_integral::value && - !etl::is_floating_point::value, T>::type + ETL_CONSTEXPR14 typename etl::enable_if::value&& + !etl::is_integral::value && + !etl::is_floating_point::value, T>::type midpoint(T a, T b) ETL_NOEXCEPT { if (a > b) @@ -153,7 +153,7 @@ namespace etl /// For ETL random access iterators. //*************************************************************************** template - ETL_CONSTEXPR T midpoint(T a, T b, typename etl::enable_if::value && + ETL_CONSTEXPR14 T midpoint(T a, T b, typename etl::enable_if::value && !etl::is_integral::value && !etl::is_floating_point::value && etl::is_same::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value , int>::type = 0) @@ -174,11 +174,11 @@ namespace etl /// Parameter 'a' must be before 'b', otherwise the result is undefined. //*************************************************************************** template - ETL_CONSTEXPR T midpoint(T a, T b, typename etl::enable_if<(!etl::is_pointer::value && - !etl::is_integral::value && - !etl::is_floating_point::value && - (etl::is_same::iterator_category, ETL_OR_STD::forward_iterator_tag>::value || - etl::is_same::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value)), int>::type = 0) + ETL_CONSTEXPR14 T midpoint(T a, T b, typename etl::enable_if<(!etl::is_pointer::value && + !etl::is_integral::value && + !etl::is_floating_point::value && + (etl::is_same::iterator_category, ETL_OR_STD::forward_iterator_tag>::value || + etl::is_same::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value)), int>::type = 0) { etl::advance(a, etl::distance(a, b) / 2U); return a; diff --git a/include/etl/poly_span.h b/include/etl/poly_span.h index 1d654529..63de7e8b 100644 --- a/include/etl/poly_span.h +++ b/include/etl/poly_span.h @@ -589,7 +589,7 @@ namespace etl typedef typename char_ptr_type::type char_ptr_t; //*************************************************************************** - ETL_CONSTEXPR pointer element_at(size_t index) const ETL_NOEXCEPT + pointer element_at(size_t index) const ETL_NOEXCEPT { char_ptr_t base = reinterpret_cast(pbegin); return reinterpret_cast(base + (index * element_size)); @@ -599,7 +599,7 @@ namespace etl /// Construct from iterator + offset + element size /// extent_ is ignored. //************************************************************************* - ETL_CONSTEXPR poly_span(TBase* pbegin_, size_t offset_, size_t /*extent_*/, size_t element_size_) ETL_NOEXCEPT + poly_span(TBase* pbegin_, size_t offset_, size_t /*extent_*/, size_t element_size_) ETL_NOEXCEPT : pbegin(reinterpret_cast(reinterpret_cast(pbegin_) + (offset_ * element_size_))) , element_size(element_size_) { @@ -957,7 +957,7 @@ protected: //************************************************************************* /// Construct from iterator + offset + size + element size //************************************************************************* - ETL_CONSTEXPR poly_span(TBase* pbegin_, size_t offset_, size_t extent_, size_t element_size_) ETL_NOEXCEPT + poly_span(TBase* pbegin_, size_t offset_, size_t extent_, size_t element_size_) ETL_NOEXCEPT : pbegin(reinterpret_cast(reinterpret_cast(pbegin_) + (offset_ * element_size_))) , element_size(element_size_) , span_extent(extent_) @@ -976,7 +976,7 @@ protected: typedef typename char_ptr_type::type char_ptr_t; //*************************************************************************** - ETL_CONSTEXPR pointer element_at(size_t index) const ETL_NOEXCEPT + pointer element_at(size_t index) const ETL_NOEXCEPT { char_ptr_t base = reinterpret_cast(pbegin); return reinterpret_cast(base + (index * element_size)); diff --git a/include/etl/profiles/determine_compiler_language_support.h b/include/etl/profiles/determine_compiler_language_support.h index 827bb713..e23c17f3 100644 --- a/include/etl/profiles/determine_compiler_language_support.h +++ b/include/etl/profiles/determine_compiler_language_support.h @@ -175,7 +175,7 @@ SOFTWARE. #endif #if !defined(ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED) - #define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED ETL_USING_CPP14 + #define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED ETL_USING_CPP11 #endif // Language standard diff --git a/include/etl/smallest.h b/include/etl/smallest.h index f423ec86..6843df5b 100644 --- a/include/etl/smallest.h +++ b/include/etl/smallest.h @@ -352,17 +352,17 @@ namespace etl private: // Determines the index of the best unsigned type for the required value. - static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + - ((VALUE > UINT16_MAX) ? 1 : 0) + - ((VALUE > UINT32_MAX) ? 1 : 0); + static ETL_CONSTANT int TYPE_INDEX = ((VALUE > UINT_LEAST8_MAX) ? 1 : 0) + + ((VALUE > UINT16_MAX) ? 1 : 0) + + ((VALUE > UINT32_MAX) ? 1 : 0); public: typedef typename private_smallest::best_fit_uint_type::type type; }; - template - ETL_CONSTANT int smallest_uint_for_value::TYPE_INDEX; + template + ETL_CONSTANT int smallest_uint_for_value::TYPE_INDEX; #if ETL_USING_CPP11 template @@ -382,16 +382,16 @@ namespace etl // Determines the index of the best signed type for the required value. static ETL_CONSTANT int TYPE_INDEX = (((VALUE > intmax_t(INT_LEAST8_MAX)) || (VALUE < intmax_t(INT_LEAST8_MIN))) ? 1 : 0) + - (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + - (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0); + (((VALUE > intmax_t(INT16_MAX)) || (VALUE < intmax_t(INT16_MIN))) ? 1 : 0) + + (((VALUE > intmax_t(INT32_MAX)) || (VALUE < intmax_t(INT32_MIN))) ? 1 : 0); public: typedef typename private_smallest::best_fit_int_type::type type; }; - template - ETL_CONSTANT int smallest_int_for_value::TYPE_INDEX; + template + ETL_CONSTANT int smallest_int_for_value::TYPE_INDEX; #if ETL_USING_CPP11 template diff --git a/include/etl/string_view.h b/include/etl/string_view.h index 753289b8..6e09c8a2 100644 --- a/include/etl/string_view.h +++ b/include/etl/string_view.h @@ -326,7 +326,7 @@ namespace etl //************************************************************************* /// Returns a const reference to the indexed value. //************************************************************************* - ETL_CONSTEXPR const_reference at(size_t i) const + const_reference at(size_t i) const { ETL_ASSERT((mbegin != ETL_NULLPTR && mend != ETL_NULLPTR), ETL_ERROR(string_view_uninitialised)); ETL_ASSERT(i < size(), ETL_ERROR(string_view_bounds)); diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h index 498f927f..5996820c 100644 --- a/include/etl/type_traits.h +++ b/include/etl/type_traits.h @@ -813,11 +813,11 @@ namespace etl // Traits are derived from the STL //***************************************************************************** -//*************************************************************************** -/// integral_constant -///\ingroup type_traits -template -struct integral_constant : std::integral_constant {}; + //*************************************************************************** + /// integral_constant + ///\ingroup type_traits + template + struct integral_constant : std::integral_constant {}; /// integral_constant specialisations ///\ingroup type_traits diff --git a/test/etl_initializer_list/test_initializer_list.cpp b/test/etl_initializer_list/test_initializer_list.cpp index 211208cf..14e84634 100644 --- a/test/etl_initializer_list/test_initializer_list.cpp +++ b/test/etl_initializer_list/test_initializer_list.cpp @@ -36,7 +36,7 @@ class Container public: //#if ETL_USING_INITIALIZER_LIST - constexpr Container(std::initializer_list init) + ETL_CONSTEXPR14 Container(std::initializer_list init) : length(init.size()) , buffer() { @@ -76,7 +76,7 @@ int main() if (c.length != 5) result = 6; - constexpr Container cc = { 1, 2, 3, 4, 5 }; + ETL_CONSTEXPR14 Container cc = { 1, 2, 3, 4, 5 }; if (cc[0] != 1) result = 7; if (cc[1] != 2) result = 8; diff --git a/test/test_array.cpp b/test/test_array.cpp index 1806af64..f78b9af6 100644 --- a/test/test_array.cpp +++ b/test/test_array.cpp @@ -700,7 +700,7 @@ namespace { auto data = etl::make_array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); - using Type = std::remove_reference_t; + using Type = etl::remove_reference_t; CHECK((std::is_same::value)); CHECK_EQUAL(0, data[0]); @@ -722,7 +722,7 @@ namespace { auto data = etl::make_array(Moveable(0), Moveable(1), Moveable(2), Moveable(3), Moveable(4), Moveable(5), Moveable(6), Moveable(7), Moveable(8), Moveable(9)); - using Type = std::remove_reference_t; + using Type = etl::remove_reference_t; CHECK((std::is_same::value)); CHECK_EQUAL(Moveable(0), data[0]); diff --git a/test/test_binary.cpp b/test/test_binary.cpp index 818b677f..3fe46377 100644 --- a/test/test_binary.cpp +++ b/test/test_binary.cpp @@ -2421,15 +2421,15 @@ namespace //************************************************************************* TEST(test_make_lsb_mask_8_bit) { - constexpr int8_t mask0 = etl::make_lsb_mask(0); - constexpr int8_t mask1 = etl::make_lsb_mask(1); - constexpr int8_t mask2 = etl::make_lsb_mask(2); - constexpr int8_t mask3 = etl::make_lsb_mask(3); - constexpr int8_t mask4 = etl::make_lsb_mask(4); - constexpr int8_t mask5 = etl::make_lsb_mask(5); - constexpr int8_t mask6 = etl::make_lsb_mask(6); - constexpr int8_t mask7 = etl::make_lsb_mask(7); - constexpr int8_t mask8 = etl::make_lsb_mask(8); + ETL_CONSTEXPR14 int8_t mask0 = etl::make_lsb_mask(0); + ETL_CONSTEXPR14 int8_t mask1 = etl::make_lsb_mask(1); + ETL_CONSTEXPR14 int8_t mask2 = etl::make_lsb_mask(2); + ETL_CONSTEXPR14 int8_t mask3 = etl::make_lsb_mask(3); + ETL_CONSTEXPR14 int8_t mask4 = etl::make_lsb_mask(4); + ETL_CONSTEXPR14 int8_t mask5 = etl::make_lsb_mask(5); + ETL_CONSTEXPR14 int8_t mask6 = etl::make_lsb_mask(6); + ETL_CONSTEXPR14 int8_t mask7 = etl::make_lsb_mask(7); + ETL_CONSTEXPR14 int8_t mask8 = etl::make_lsb_mask(8); CHECK(int8_t(etl::b00000000) == mask0); CHECK(int8_t(etl::b00000001) == mask1); @@ -2455,15 +2455,15 @@ namespace //************************************************************************* TEST(test_make_lsb_mask_64_bit) { - constexpr int64_t mask0 = etl::make_lsb_mask(0); - constexpr int64_t mask1 = etl::make_lsb_mask(8); - constexpr int64_t mask2 = etl::make_lsb_mask(16); - constexpr int64_t mask3 = etl::make_lsb_mask(24); - constexpr int64_t mask4 = etl::make_lsb_mask(32); - constexpr int64_t mask5 = etl::make_lsb_mask(40); - constexpr int64_t mask6 = etl::make_lsb_mask(48); - constexpr int64_t mask7 = etl::make_lsb_mask(56); - constexpr int64_t mask8 = etl::make_lsb_mask(64); + ETL_CONSTEXPR14 int64_t mask0 = etl::make_lsb_mask(0); + ETL_CONSTEXPR14 int64_t mask1 = etl::make_lsb_mask(8); + ETL_CONSTEXPR14 int64_t mask2 = etl::make_lsb_mask(16); + ETL_CONSTEXPR14 int64_t mask3 = etl::make_lsb_mask(24); + ETL_CONSTEXPR14 int64_t mask4 = etl::make_lsb_mask(32); + ETL_CONSTEXPR14 int64_t mask5 = etl::make_lsb_mask(40); + ETL_CONSTEXPR14 int64_t mask6 = etl::make_lsb_mask(48); + ETL_CONSTEXPR14 int64_t mask7 = etl::make_lsb_mask(56); + ETL_CONSTEXPR14 int64_t mask8 = etl::make_lsb_mask(64); CHECK_EQUAL(int64_t(0x0000000000000000), mask0); CHECK_EQUAL(int64_t(0x00000000000000FF), mask1); @@ -2517,15 +2517,15 @@ namespace //************************************************************************* TEST(test_make_msb_mask_8_bit) { - constexpr int8_t mask0 = etl::make_msb_mask(0); - constexpr int8_t mask1 = etl::make_msb_mask(1); - constexpr int8_t mask2 = etl::make_msb_mask(2); - constexpr int8_t mask3 = etl::make_msb_mask(3); - constexpr int8_t mask4 = etl::make_msb_mask(4); - constexpr int8_t mask5 = etl::make_msb_mask(5); - constexpr int8_t mask6 = etl::make_msb_mask(6); - constexpr int8_t mask7 = etl::make_msb_mask(7); - constexpr int8_t mask8 = etl::make_msb_mask(8); + ETL_CONSTEXPR14 int8_t mask0 = etl::make_msb_mask(0); + ETL_CONSTEXPR14 int8_t mask1 = etl::make_msb_mask(1); + ETL_CONSTEXPR14 int8_t mask2 = etl::make_msb_mask(2); + ETL_CONSTEXPR14 int8_t mask3 = etl::make_msb_mask(3); + ETL_CONSTEXPR14 int8_t mask4 = etl::make_msb_mask(4); + ETL_CONSTEXPR14 int8_t mask5 = etl::make_msb_mask(5); + ETL_CONSTEXPR14 int8_t mask6 = etl::make_msb_mask(6); + ETL_CONSTEXPR14 int8_t mask7 = etl::make_msb_mask(7); + ETL_CONSTEXPR14 int8_t mask8 = etl::make_msb_mask(8); CHECK(int8_t(etl::b00000000) == mask0); CHECK(int8_t(etl::b10000000) == mask1); @@ -2551,15 +2551,15 @@ namespace //************************************************************************* TEST(test_make_msb_mask_64_bit) { - constexpr int64_t mask0 = etl::make_msb_mask(0); - constexpr int64_t mask1 = etl::make_msb_mask(8); - constexpr int64_t mask2 = etl::make_msb_mask(16); - constexpr int64_t mask3 = etl::make_msb_mask(24); - constexpr int64_t mask4 = etl::make_msb_mask(32); - constexpr int64_t mask5 = etl::make_msb_mask(40); - constexpr int64_t mask6 = etl::make_msb_mask(48); - constexpr int64_t mask7 = etl::make_msb_mask(56); - constexpr int64_t mask8 = etl::make_msb_mask(64); + ETL_CONSTEXPR14 int64_t mask0 = etl::make_msb_mask(0); + ETL_CONSTEXPR14 int64_t mask1 = etl::make_msb_mask(8); + ETL_CONSTEXPR14 int64_t mask2 = etl::make_msb_mask(16); + ETL_CONSTEXPR14 int64_t mask3 = etl::make_msb_mask(24); + ETL_CONSTEXPR14 int64_t mask4 = etl::make_msb_mask(32); + ETL_CONSTEXPR14 int64_t mask5 = etl::make_msb_mask(40); + ETL_CONSTEXPR14 int64_t mask6 = etl::make_msb_mask(48); + ETL_CONSTEXPR14 int64_t mask7 = etl::make_msb_mask(56); + ETL_CONSTEXPR14 int64_t mask8 = etl::make_msb_mask(64); CHECK_EQUAL(int64_t(0x0000000000000000), mask0); CHECK_EQUAL(int64_t(0xFF00000000000000), mask1); diff --git a/test/test_bitset_legacy.cpp b/test/test_bitset_legacy.cpp index 6421370a..65e1e45e 100644 --- a/test/test_bitset_legacy.cpp +++ b/test/test_bitset_legacy.cpp @@ -1249,13 +1249,13 @@ namespace //************************************************************************* TEST(test_find_next_github_issue_617) { - etl::bitset<64> bs1(0xC000'0000'0000'0031ULL); + etl::bitset<64> bs1(0xC000000000000031ULL); size_t bs1fnt1 = bs1.find_next(true, 10); size_t bs1fnt2 = bs1.find_next(true, 59); CHECK_EQUAL(62U, bs1fnt1); CHECK_EQUAL(62U, bs1fnt2); - etl::bitset<64> bs2(0x3FFF'FFFF'FFFF'FFCEULL); + etl::bitset<64> bs2(0x3FFFFFFFFFFFFFCEULL); size_t bs2fnf1 = bs2.find_next(false, 10); size_t bs2fnf2 = bs2.find_next(false, 59); CHECK_EQUAL(62U, bs2fnf1); diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp index 7519dcb5..4d758c8e 100644 --- a/test/test_bitset_new_default_element_type.cpp +++ b/test/test_bitset_new_default_element_type.cpp @@ -44,7 +44,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_left_bitset(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_left_bitset(ull value, size_t shift) { etl::bitset data(value); @@ -58,7 +58,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) { etl::bitset data1(value); etl::bitset data2; @@ -73,7 +73,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_right_bitset(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_right_bitset(ull value, size_t shift) { etl::bitset data(value); @@ -87,7 +87,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) { etl::bitset data1(value); etl::bitset data2; @@ -105,8 +105,8 @@ namespace //************************************************************************* TEST(test_default_constructor) { - constexpr std::bitset<60> compare; - constexpr etl::bitset<60> data; + ETL_CONSTEXPR14 std::bitset<60> compare; + ETL_CONSTEXPR14 etl::bitset<60> data; CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -822,8 +822,8 @@ namespace //************************************************************************* TEST(test_construct_from_value) { - constexpr std::bitset<60> compare(0x123456731234567ULL); - constexpr etl::bitset<60> data(0x123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -837,9 +837,9 @@ namespace //************************************************************************* TEST(test_copy_construct) { - constexpr std::bitset<60> compare(0x123456731234567ULL); - constexpr etl::bitset<60> data(0x123456731234567ULL); - constexpr etl::bitset<60> data_copy(data); + ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data_copy(data); CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); @@ -853,8 +853,8 @@ namespace //************************************************************************* TEST(test_construct_from_excess_value) { - constexpr std::bitset<60> compare(0x8765432187654321ULL); - constexpr etl::bitset<60> data(0x8765432187654321ULL); + ETL_CONSTEXPR14 std::bitset<60> compare(0x8765432187654321ULL); + ETL_CONSTEXPR14 etl::bitset<60> data(0x8765432187654321ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -1127,8 +1127,8 @@ namespace //************************************************************************* TEST(test_value_u16_min) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr uint16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1136,8 +1136,8 @@ namespace //************************************************************************* TEST(test_value_u16_max) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - constexpr uint16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1145,8 +1145,8 @@ namespace //************************************************************************* TEST(test_value_s16_min) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr int16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1154,8 +1154,8 @@ namespace //************************************************************************* TEST(test_value_s16_max) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - constexpr int16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1163,8 +1163,8 @@ namespace //************************************************************************* TEST(test_value_u32_min) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr uint32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1172,8 +1172,8 @@ namespace //************************************************************************* TEST(test_value_u32_max) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr uint32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1181,8 +1181,8 @@ namespace //************************************************************************* TEST(test_value_s32_min) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1190,8 +1190,8 @@ namespace //************************************************************************* TEST(test_value_s32_max) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1199,8 +1199,8 @@ namespace //************************************************************************* TEST(test_value_u64_min) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr uint64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1208,8 +1208,8 @@ namespace //************************************************************************* TEST(test_value_u64_max) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr uint64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1217,8 +1217,8 @@ namespace //************************************************************************* TEST(test_value_s64_min) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1226,8 +1226,8 @@ namespace //************************************************************************* TEST(test_value_s64_max) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1308,23 +1308,23 @@ namespace //************************************************************************* TEST(test_index_operator_read) { - constexpr std::bitset<60> compare(0x3123456731234567ULL); - constexpr etl::bitset<60> data(0x3123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<60> compare(0x3123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data(0x3123456731234567ULL); - constexpr bool bc0 = compare[1U]; - constexpr bool bd0 = data[1U]; + ETL_CONSTEXPR14 bool bc0 = compare[1U]; + ETL_CONSTEXPR14 bool bd0 = data[1U]; CHECK_EQUAL(bc0, bd0); - constexpr bool bc3 = compare[3U]; - constexpr bool bd3 = data[3U]; + ETL_CONSTEXPR14 bool bc3 = compare[3U]; + ETL_CONSTEXPR14 bool bd3 = data[3U]; CHECK_EQUAL(bc3, bd3); - constexpr bool bc7 = compare[7U]; - constexpr bool bd7 = data[7U]; + ETL_CONSTEXPR14 bool bc7 = compare[7U]; + ETL_CONSTEXPR14 bool bd7 = data[7U]; CHECK_EQUAL(bc7, bd7); - constexpr bool bc13 = compare[13U]; - constexpr bool bd13 = data[13U]; + ETL_CONSTEXPR14 bool bc13 = compare[13U]; + ETL_CONSTEXPR14 bool bd13 = data[13U]; CHECK_EQUAL(bc13, bd13); } @@ -1347,15 +1347,15 @@ namespace //************************************************************************* TEST(test_any) { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.any(); - constexpr bool bd2 = data2.any(); - constexpr bool bd3 = data3.any(); - constexpr bool bd4 = data4.any(); + ETL_CONSTEXPR14 bool bd1 = data1.any(); + ETL_CONSTEXPR14 bool bd2 = data2.any(); + ETL_CONSTEXPR14 bool bd3 = data3.any(); + ETL_CONSTEXPR14 bool bd4 = data4.any(); CHECK_FALSE(bd1); CHECK_TRUE(bd2); @@ -1366,15 +1366,15 @@ namespace //************************************************************************* TEST(test_none) { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.none(); - constexpr bool bd2 = data2.none(); - constexpr bool bd3 = data3.none(); - constexpr bool bd4 = data4.none(); + ETL_CONSTEXPR14 bool bd1 = data1.none(); + ETL_CONSTEXPR14 bool bd2 = data2.none(); + ETL_CONSTEXPR14 bool bd3 = data3.none(); + ETL_CONSTEXPR14 bool bd4 = data4.none(); CHECK_TRUE(bd1); CHECK_FALSE(bd2); @@ -1385,15 +1385,15 @@ namespace //************************************************************************* TEST(test_all) { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.all(); - constexpr bool bd2 = data2.all(); - constexpr bool bd3 = data3.all(); - constexpr bool bd4 = data4.all(); + ETL_CONSTEXPR14 bool bd1 = data1.all(); + ETL_CONSTEXPR14 bool bd2 = data2.all(); + ETL_CONSTEXPR14 bool bd3 = data3.all(); + ETL_CONSTEXPR14 bool bd4 = data4.all(); CHECK_FALSE(bd1); CHECK_FALSE(bd2); @@ -1494,12 +1494,12 @@ namespace //************************************************************************* TEST(test_equality_operator) { - constexpr etl::bitset<60> data1(0x123456781234567ULL); - constexpr etl::bitset<60> data2(0x123456781234567ULL); - constexpr etl::bitset<60> data3; + ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data3; - constexpr bool equal = (data1 == data2); - constexpr bool not_equal = !(data1 == data3); + ETL_CONSTEXPR14 bool equal = (data1 == data2); + ETL_CONSTEXPR14 bool not_equal = !(data1 == data3); CHECK(equal); CHECK(not_equal); @@ -1508,12 +1508,12 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - constexpr etl::bitset<60> data1(0x123456781234567ULL); - constexpr etl::bitset<60> data2(0x123456781234567ULL); - constexpr etl::bitset<60> data3; + ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<60> data3; - constexpr bool equal = !(data1 != data2); - constexpr bool not_equal = (data1 != data3); + ETL_CONSTEXPR14 bool equal = !(data1 != data2); + ETL_CONSTEXPR14 bool not_equal = (data1 != data3); CHECK(equal); CHECK(not_equal); @@ -1522,9 +1522,9 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - constexpr etl::bitset<60> shift1(0x2468ACF0ULL); - constexpr etl::bitset<60> shift2(0x48D159E0ULL); - constexpr etl::bitset<60> shift11(0x91A2B3C000ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift1(0x2468ACF0ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159E0ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift11(0x91A2B3C000ULL); CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1); CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2); @@ -1534,8 +1534,8 @@ namespace //************************************************************************* TEST(test_shift_left_operator_overflow) { - constexpr etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U)); - constexpr etl::bitset<31> shifted(0x7FFFFFFEUL); + ETL_CONSTEXPR14 etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U)); + ETL_CONSTEXPR14 etl::bitset<31> shifted(0x7FFFFFFEUL); CHECK(data == shifted); } @@ -1543,16 +1543,16 @@ namespace //************************************************************************* TEST(test_shift_left_copy_operator) { - constexpr etl::bitset<60> shift8(0x1234567800ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift8(0x1234567800ULL); CHECK_EQUAL_HEX(shift8.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value()); - constexpr etl::bitset<60> shift16(0x123456780000ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift16(0x123456780000ULL); CHECK_EQUAL_HEX(shift16.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value()); - constexpr etl::bitset<60> shift24(0x12345678000000ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12345678000000ULL); CHECK_EQUAL_HEX(shift24.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value()); - constexpr etl::bitset<60> shift60(0x0000000000000000ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift60(0x0000000000000000ULL); CHECK_EQUAL_HEX(shift60.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value()); } @@ -1632,9 +1632,9 @@ namespace //************************************************************************* TEST(test_shift_right_operator) { - constexpr etl::bitset<60> shift1(0x91A2B3CULL); - constexpr etl::bitset<60> shift2(0x48D159EULL); - constexpr etl::bitset<60> shift11(0x2468AULL); + ETL_CONSTEXPR14 etl::bitset<60> shift1(0x91A2B3CULL); + ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159EULL); + ETL_CONSTEXPR14 etl::bitset<60> shift11(0x2468AULL); CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1); CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2); @@ -1644,16 +1644,16 @@ namespace //************************************************************************* TEST(test_shift_right_copy_operator) { - constexpr etl::bitset<60> shift8(0x123456ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift8(0x123456ULL); CHECK_EQUAL_HEX(shift8.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value()); - constexpr etl::bitset<60> shift16(0x1234ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift16(0x1234ULL); CHECK_EQUAL_HEX(shift16.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value()); - constexpr etl::bitset<60> shift24(0x12ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12ULL); CHECK_EQUAL_HEX(shift24.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value()); - constexpr etl::bitset<60> shift60(0x00ULL); + ETL_CONSTEXPR14 etl::bitset<60> shift60(0x00ULL); CHECK_EQUAL_HEX(shift60.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value()); } @@ -1873,45 +1873,45 @@ namespace //************************************************************************* TEST(test_find_first) { - constexpr etl::bitset<9> bs1(ull(0x0000)); - constexpr size_t bs1fff = bs1.find_first(false); - constexpr size_t bs1fft = bs1.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000)); + ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false); + ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true); CHECK_EQUAL(0U, bs1fff); CHECK_EQUAL(etl::bitset<>::npos, bs1fft); - constexpr etl::bitset<9> bs2(ull(0x01FF)); - constexpr size_t bs2fff = bs2.find_first(false); - constexpr size_t bs2fft = bs2.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x01FF)); + ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false); + ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true); CHECK_EQUAL(etl::bitset<>::npos, bs2fff); CHECK_EQUAL(0U, bs2fft); - constexpr etl::bitset<9> bs3(ull(0x0001)); - constexpr size_t bs3fff = bs3.find_first(false); - constexpr size_t bs3fft = bs3.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x0001)); + ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false); + ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true); CHECK_EQUAL(1U, bs3fff); CHECK_EQUAL(0U, bs3fft); - constexpr etl::bitset<9> bs4(ull(0x0020)); - constexpr size_t bs4fff = bs4.find_first(false); - constexpr size_t bs4fft = bs4.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0020)); + ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false); + ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true); CHECK_EQUAL(0U, bs4fff); CHECK_EQUAL(5U, bs4fft); - constexpr etl::bitset<9> bs5(ull(0x0021)); - constexpr size_t bs5fff = bs5.find_first(false); - constexpr size_t bs5fft = bs5.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs5(ull(0x0021)); + ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false); + ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true); CHECK_EQUAL(1U, bs5fff); CHECK_EQUAL(0U, bs5fft); - constexpr etl::bitset<9> bs6(ull(0x000E)); - constexpr size_t bs6fff = bs6.find_first(false); - constexpr size_t bs6fft = bs6.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs6(ull(0x000E)); + ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false); + ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true); CHECK_EQUAL(0U, bs6fff); CHECK_EQUAL(1U, bs6fft); - constexpr etl::bitset<9> bs7(ull(0x31)); - constexpr size_t bs7fff = bs7.find_first(false); - constexpr size_t bs7fft = bs7.find_first(true); + ETL_CONSTEXPR14 etl::bitset<9> bs7(ull(0x31)); + ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false); + ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true); CHECK_EQUAL(1U, bs7fff); CHECK_EQUAL(0U, bs7fft); } @@ -1919,34 +1919,34 @@ namespace //************************************************************************* TEST(test_find_next) { - constexpr etl::bitset<9> bs1(ull(0x0000)); - constexpr size_t bs1fnf0 = bs1.find_next(false, 0); - constexpr size_t bs1fnf1 = bs1.find_next(false, 1); - constexpr size_t bs1fnt2 = bs1.find_next(true, 2); + ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000)); + ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1); + ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2); CHECK_EQUAL(0U, bs1fnf0); CHECK_EQUAL(1U, bs1fnf1); CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); - constexpr etl::bitset<9> bs2(ull(0x1FF)); - constexpr size_t bs2fnt0 = bs2.find_next(true, 0); - constexpr size_t bs2fnt1 = bs2.find_next(true, 1); - constexpr size_t bs2fnf2 = bs2.find_next(false, 2); + ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x1FF)); + ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2); CHECK_EQUAL(0U, bs2fnt0); CHECK_EQUAL(1U, bs2fnt1); CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); - constexpr etl::bitset<9> bs3(ull(0x000E)); - constexpr size_t bs3fnf0 = bs3.find_next(false, 0); - constexpr size_t bs3fnt1 = bs3.find_next(true, 1); - constexpr size_t bs3fnf2 = bs3.find_next(false, 2); + ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x000E)); + ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2); CHECK_EQUAL(0U, bs3fnf0); CHECK_EQUAL(1U, bs3fnt1); CHECK_EQUAL(4U, bs3fnf2); - constexpr etl::bitset<9> bs4(ull(0x0031)); - constexpr size_t bs4fnt0 = bs4.find_next(true, 0); - constexpr size_t bs4fnf0 = bs4.find_next(false, 0); - constexpr size_t bs4fnt1 = bs4.find_next(true, 1); + ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0031)); + ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1); CHECK_EQUAL(0U, bs4fnt0); CHECK_EQUAL(1U, bs4fnf0); CHECK_EQUAL(4U, bs4fnt1); @@ -1955,21 +1955,21 @@ namespace //************************************************************************* TEST(test_find_next_github_issue_617) { - constexpr etl::bitset<64> bs1(ull(0xC000'0000'0000'0031)); - constexpr size_t bs1fnt1 = bs1.find_next(true, 10); - constexpr size_t bs1fnt2 = bs1.find_next(true, 59); + ETL_CONSTEXPR14 etl::bitset<64> bs1(ull(0xC000000000000031)); + ETL_CONSTEXPR14 size_t bs1fnt1 = bs1.find_next(true, 10); + ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 59); CHECK_EQUAL(62U, bs1fnt1); CHECK_EQUAL(62U, bs1fnt2); - constexpr etl::bitset<64> bs2(ull(0x3FFF'FFFF'FFFF'FFCE)); - constexpr size_t bs2fnf1 = bs2.find_next(false, 10); - constexpr size_t bs2fnf2 = bs2.find_next(false, 59); + ETL_CONSTEXPR14 etl::bitset<64> bs2(ull(0x3FFFFFFFFFFFFFCE)); + ETL_CONSTEXPR14 size_t bs2fnf1 = bs2.find_next(false, 10); + ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 59); CHECK_EQUAL(62U, bs2fnf1); CHECK_EQUAL(62U, bs2fnf2); - constexpr etl::bitset<64, uint32_t> bs32(ull(0xC000'0000'0000'0031)); - constexpr size_t bs32fnt1 = bs32.find_next(true, 10); - constexpr size_t bs32fnt2 = bs32.find_next(true, 59); + ETL_CONSTEXPR14 etl::bitset<64, uint32_t> bs32(ull(0xC000000000000031)); + ETL_CONSTEXPR14 size_t bs32fnt1 = bs32.find_next(true, 10); + ETL_CONSTEXPR14 size_t bs32fnt2 = bs32.find_next(true, 59); CHECK_EQUAL(62U, bs32fnt1); CHECK_EQUAL(62U, bs32fnt2); } @@ -2020,7 +2020,7 @@ namespace //************************************************************************* TEST(test_to_string) { - constexpr etl::bitset<32> b(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); etl::string<32> text = b.to_string('.', '*'); std::string stdtext = b.to_string('.', '*'); @@ -2032,7 +2032,7 @@ namespace //************************************************************************* TEST(test_to_wstring) { - constexpr etl::bitset<32> b(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); etl::wstring<32> text = b.to_string>(L'.', L'*'); std::wstring stdtext = b.to_string(L'.', L'*'); @@ -2044,7 +2044,7 @@ namespace //************************************************************************* TEST(test_to_u16string) { - constexpr etl::bitset<32> b(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); etl::u16string<32> text = b.to_string>(u'.', u'*'); std::u16string stdtext = b.to_string(u'.', u'*'); @@ -2056,7 +2056,7 @@ namespace //************************************************************************* TEST(test_to_u32string) { - constexpr etl::bitset<32> b(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); etl::u32string<32> text = b.to_string>(U'.', U'*'); std::u32string stdtext = b.to_string(U'.', U'*'); diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index e0b1d1b9..f8cb4691 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -44,7 +44,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_left_bitset(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_left_bitset(ull value, size_t shift) { ull mask = 0ULL; @@ -71,7 +71,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) { etl::bitset data1(value); etl::bitset data2; @@ -86,7 +86,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_right_bitset(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_right_bitset(ull value, size_t shift) { etl::bitset data(value); @@ -104,7 +104,7 @@ namespace //************************************************************************* template - constexpr etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) + ETL_CONSTEXPR14 etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) { etl::bitset data1(value); etl::bitset data2; @@ -122,8 +122,8 @@ namespace //************************************************************************* TEST(test_default_constructor) { - constexpr std::bitset<64> compare; - constexpr etl::bitset<64, int64_t> data; + ETL_CONSTEXPR14 std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data; CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -151,8 +151,8 @@ namespace //************************************************************************* TEST(test_construct_from_value) { - constexpr std::bitset<64> compare(0x123456731234567ULL); - constexpr etl::bitset<64, int64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -167,9 +167,9 @@ namespace //************************************************************************* TEST(test_copy_construct) { - constexpr std::bitset<64> compare(0x123456731234567ULL); - constexpr etl::bitset<64, int64_t> data(0x123456731234567ULL); - constexpr etl::bitset<64, int64_t> data_copy(data); + ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data_copy(data); CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); @@ -183,8 +183,8 @@ namespace //************************************************************************* TEST(test_construct_from_excess_value) { - constexpr std::bitset<64> compare(0x8765432187654321ULL); - constexpr etl::bitset<64, int64_t> data(0x8765432187654321ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x8765432187654321ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -276,7 +276,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_set_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_set_helper() { etl::bitset<64, int64_t> data; data.set(); @@ -287,15 +287,15 @@ namespace TEST(test_set) { std::bitset<64> compare; - constexpr etl::bitset<64, int64_t> data(test_set_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_set_helper()); compare.set(); - constexpr auto size = data.size(); - constexpr auto count = data.count(); - constexpr auto none = data.none(); - constexpr auto any = data.any(); - constexpr auto all = data.all(); + ETL_CONSTEXPR14 auto size = data.size(); + ETL_CONSTEXPR14 auto count = data.count(); + ETL_CONSTEXPR14 auto none = data.none(); + ETL_CONSTEXPR14 auto any = data.any(); + ETL_CONSTEXPR14 auto all = data.all(); CHECK_EQUAL(compare.size(), size); CHECK_EQUAL(compare.count(), count); @@ -472,8 +472,8 @@ namespace //************************************************************************* TEST(test_value_u8_min) { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); - constexpr uint8_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -481,8 +481,8 @@ namespace //************************************************************************* TEST(test_value_u8_max) { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); - constexpr uint8_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -490,8 +490,8 @@ namespace //************************************************************************* TEST(test_value_s8_min) { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); - constexpr int8_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -499,8 +499,8 @@ namespace //************************************************************************* TEST(test_value_s8_max) { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); - constexpr int8_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -508,8 +508,8 @@ namespace //************************************************************************* TEST(test_value_u16_min) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr uint16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -517,8 +517,8 @@ namespace //************************************************************************* TEST(test_value_u16_max) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - constexpr uint16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -526,8 +526,8 @@ namespace //************************************************************************* TEST(test_value_s16_min) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr int16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -535,8 +535,8 @@ namespace //************************************************************************* TEST(test_value_s16_max) { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - constexpr int16_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -544,8 +544,8 @@ namespace //************************************************************************* TEST(test_value_u32_min) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -553,8 +553,8 @@ namespace //************************************************************************* TEST(test_value_u32_max) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -562,8 +562,8 @@ namespace //************************************************************************* TEST(test_value_s32_min) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -571,8 +571,8 @@ namespace //************************************************************************* TEST(test_value_s32_max) { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr int32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int32_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -580,8 +580,8 @@ namespace //************************************************************************* TEST(test_value_u64_min) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -589,8 +589,8 @@ namespace //************************************************************************* TEST(test_value_u64_max) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -598,8 +598,8 @@ namespace //************************************************************************* TEST(test_value_s64_min) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -607,8 +607,8 @@ namespace //************************************************************************* TEST(test_value_s64_max) { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr int64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -638,7 +638,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_reset_helper() { etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(); @@ -649,7 +649,7 @@ namespace TEST(test_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<64, int64_t> data(test_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_reset_helper()); compare.reset(); @@ -666,7 +666,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_position_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_position_reset_helper() { etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(1); @@ -680,7 +680,7 @@ namespace TEST(test_position_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<64, int64_t> data(test_position_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_position_reset_helper()); compare.reset(1); compare.reset(3); @@ -702,28 +702,28 @@ namespace //************************************************************************* TEST(test_index_operator_read) { - constexpr std::bitset<64> compare(0x3123456731234567ULL); - constexpr etl::bitset<64, int64_t> data(0x3123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x3123456731234567ULL); - constexpr bool bc0 = compare[1U]; - constexpr bool bd0 = data[1U]; + ETL_CONSTEXPR14 bool bc0 = compare[1U]; + ETL_CONSTEXPR14 bool bd0 = data[1U]; CHECK_EQUAL(bc0, bd0); - constexpr bool bc3 = compare[3U]; - constexpr bool bd3 = data[3U]; + ETL_CONSTEXPR14 bool bc3 = compare[3U]; + ETL_CONSTEXPR14 bool bd3 = data[3U]; CHECK_EQUAL(bc3, bd3); - constexpr bool bc7 = compare[7U]; - constexpr bool bd7 = data[7U]; + ETL_CONSTEXPR14 bool bc7 = compare[7U]; + ETL_CONSTEXPR14 bool bd7 = data[7U]; CHECK_EQUAL(bc7, bd7); - constexpr bool bc13 = compare[13U]; - constexpr bool bd13 = data[13U]; + ETL_CONSTEXPR14 bool bc13 = compare[13U]; + ETL_CONSTEXPR14 bool bd13 = data[13U]; CHECK_EQUAL(bc13, bd13); } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_index_operator_write_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_index_operator_write_helper() { etl::bitset<64, int64_t> data; @@ -737,7 +737,7 @@ namespace TEST(test_index_operator_write) { - constexpr etl::bitset<64, int64_t> data(test_index_operator_write_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_index_operator_write_helper()); CHECK(data[1U]); CHECK(data[3U]); @@ -748,15 +748,15 @@ namespace //************************************************************************* TEST(test_any) { - constexpr etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.any(); - constexpr bool bd2 = data2.any(); - constexpr bool bd3 = data3.any(); - constexpr bool bd4 = data4.any(); + ETL_CONSTEXPR14 bool bd1 = data1.any(); + ETL_CONSTEXPR14 bool bd2 = data2.any(); + ETL_CONSTEXPR14 bool bd3 = data3.any(); + ETL_CONSTEXPR14 bool bd4 = data4.any(); CHECK_FALSE(bd1); CHECK_TRUE(bd2); @@ -767,17 +767,17 @@ namespace //************************************************************************* TEST(test_any_with_mask) { - constexpr etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); - constexpr ull mask = ull(0x0FFFFFFFFFFFFFFF); + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); - constexpr bool bd1 = data1.any(mask); - constexpr bool bd2 = data2.any(mask); - constexpr bool bd3 = data3.any(mask); - constexpr bool bd4 = data4.any(mask); + ETL_CONSTEXPR14 bool bd1 = data1.any(mask); + ETL_CONSTEXPR14 bool bd2 = data2.any(mask); + ETL_CONSTEXPR14 bool bd3 = data3.any(mask); + ETL_CONSTEXPR14 bool bd4 = data4.any(mask); CHECK_FALSE(bd1); CHECK_TRUE(bd2); @@ -788,15 +788,15 @@ namespace //************************************************************************* TEST(test_none) { - constexpr etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.none(); - constexpr bool bd2 = data2.none(); - constexpr bool bd3 = data3.none(); - constexpr bool bd4 = data4.none(); + ETL_CONSTEXPR14 bool bd1 = data1.none(); + ETL_CONSTEXPR14 bool bd2 = data2.none(); + ETL_CONSTEXPR14 bool bd3 = data3.none(); + ETL_CONSTEXPR14 bool bd4 = data4.none(); CHECK_TRUE(bd1); CHECK_FALSE(bd2); @@ -807,17 +807,17 @@ namespace //************************************************************************* TEST(test_none_with_mask) { - constexpr etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); - constexpr ull mask = ull(0x0FFFFFFFFFFFFFFF); + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); - constexpr bool bd1 = data1.none(mask); - constexpr bool bd2 = data2.none(mask); - constexpr bool bd3 = data3.none(mask); - constexpr bool bd4 = data4.none(mask); + ETL_CONSTEXPR14 bool bd1 = data1.none(mask); + ETL_CONSTEXPR14 bool bd2 = data2.none(mask); + ETL_CONSTEXPR14 bool bd3 = data3.none(mask); + ETL_CONSTEXPR14 bool bd4 = data4.none(mask); CHECK_TRUE(bd1); CHECK_FALSE(bd2); @@ -828,15 +828,15 @@ namespace //************************************************************************* TEST(test_all) { - constexpr etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); - constexpr bool bd1 = data1.all(); - constexpr bool bd2 = data2.all(); - constexpr bool bd3 = data3.all(); - constexpr bool bd4 = data4.all(); + ETL_CONSTEXPR14 bool bd1 = data1.all(); + ETL_CONSTEXPR14 bool bd2 = data2.all(); + ETL_CONSTEXPR14 bool bd3 = data3.all(); + ETL_CONSTEXPR14 bool bd4 = data4.all(); CHECK_FALSE(bd1); CHECK_FALSE(bd2); @@ -847,17 +847,17 @@ namespace //************************************************************************* TEST(test_all_with_mask) { - constexpr etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - constexpr etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - constexpr etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - constexpr etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); - constexpr ull mask = ull(0x0FFFFFFFFFFFFFFF); + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); - constexpr bool bd1 = data1.all(mask); - constexpr bool bd2 = data2.all(mask); - constexpr bool bd3 = data3.all(mask); - constexpr bool bd4 = data4.all(mask); + ETL_CONSTEXPR14 bool bd1 = data1.all(mask); + ETL_CONSTEXPR14 bool bd2 = data2.all(mask); + ETL_CONSTEXPR14 bool bd3 = data3.all(mask); + ETL_CONSTEXPR14 bool bd4 = data4.all(mask); CHECK_FALSE(bd1); CHECK_FALSE(bd2); @@ -866,7 +866,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_flip_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_helper() { etl::bitset<64, int64_t> data; data.flip(); @@ -877,7 +877,7 @@ namespace TEST(test_flip) { std::bitset<64> compare; - constexpr etl::bitset<64, int64_t> data(test_flip_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_helper()); compare.flip(); @@ -888,7 +888,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_flip_position_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_position_helper() { etl::bitset<64, int64_t> data; data.flip(1); @@ -902,7 +902,7 @@ namespace TEST(test_flip_position) { std::bitset<64> compare; - constexpr etl::bitset<64, int64_t> data(test_flip_position_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_position_helper()); compare.flip(1); compare.flip(3); @@ -916,7 +916,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_flip_reference_helper() + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_reference_helper() { etl::bitset<64, int64_t> data; data[1].flip(); @@ -930,7 +930,7 @@ namespace TEST(test_flip_reference) { std::bitset<64> compare; - constexpr etl::bitset<64, int64_t> data(test_flip_reference_helper()); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_reference_helper()); compare[1].flip(); compare[3].flip(); @@ -955,7 +955,7 @@ namespace } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from) + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from) { to = from; @@ -964,9 +964,9 @@ namespace TEST(test_assignment_operator) { - constexpr std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1)); + ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1)); for (size_t i = 0UL; i < data2.size(); ++i) { @@ -977,12 +977,12 @@ namespace //************************************************************************* TEST(test_equality_operator) { - constexpr etl::bitset<64, int64_t> data1(0x123456781234567ULL); - constexpr etl::bitset<64, int64_t> data2(0x123456781234567ULL); - constexpr etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; - constexpr bool equal = (data1 == data2); - constexpr bool not_equal = !(data1 == data3); + ETL_CONSTEXPR14 bool equal = (data1 == data2); + ETL_CONSTEXPR14 bool not_equal = !(data1 == data3); CHECK(equal); CHECK(not_equal); @@ -991,12 +991,12 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - constexpr etl::bitset<64, int64_t> data1(0x123456781234567ULL); - constexpr etl::bitset<64, int64_t> data2(0x123456781234567ULL); - constexpr etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; - constexpr bool equal = !(data1 != data2); - constexpr bool not_equal = (data1 != data3); + ETL_CONSTEXPR14 bool equal = !(data1 != data2); + ETL_CONSTEXPR14 bool not_equal = (data1 != data3); CHECK(equal); CHECK(not_equal); @@ -1005,9 +1005,9 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - constexpr etl::bitset<64, int64_t> shift1(0x2468ACF0ULL); - constexpr etl::bitset<64, int64_t> shift2(0x48D159E0ULL); - constexpr etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x2468ACF0ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159E0ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL); CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 1U)) == shift1); CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 2U)) == shift2); @@ -1017,8 +1017,8 @@ namespace //************************************************************************* TEST(test_shift_left_operator_overflow) { - constexpr etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U)); - constexpr etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL); + ETL_CONSTEXPR14 etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U)); + ETL_CONSTEXPR14 etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL); CHECK_EQUAL_HEX(shifted.value(), data.value()); } @@ -1026,16 +1026,16 @@ namespace //************************************************************************* TEST(test_shift_left_copy_operator) { - constexpr etl::bitset<64, int64_t> shift8(0x1234567800ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x1234567800ULL); CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); - constexpr etl::bitset<64, int64_t> shift16(0x123456780000ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x123456780000ULL); CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); - constexpr etl::bitset<64, int64_t> shift24(0x12345678000000ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12345678000000ULL); CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); - constexpr etl::bitset<64, int64_t> shift64(0x0000000000000000ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift64(0x0000000000000000ULL); CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 64U).value())); } @@ -1114,9 +1114,9 @@ namespace //************************************************************************* TEST(test_shift_right_operator) { - constexpr etl::bitset<64, int64_t> shift1(0x91A2B3CULL); - constexpr etl::bitset<64, int64_t> shift2(0x48D159EULL); - constexpr etl::bitset<64, int64_t> shift11(0x2468AULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x91A2B3CULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159EULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x2468AULL); CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 1U).value())); CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 2U).value())); @@ -1126,16 +1126,16 @@ namespace //************************************************************************* TEST(test_shift_right_copy_operator) { - constexpr etl::bitset<64, int64_t> shift8(0x123456ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x123456ULL); CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); - constexpr etl::bitset<64, int64_t> shift16(0x1234ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x1234ULL); CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); - constexpr etl::bitset<64, int64_t> shift24(0x12ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12ULL); CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); - constexpr etl::bitset<64, int64_t> shift60(0x00ULL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift60(0x00ULL); CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 60U).value())); } @@ -1287,16 +1287,16 @@ namespace //************************************************************************* TEST(test_and_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL); - constexpr etl::bitset<64, int64_t> data3 = data1 & data2; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 & data2; CHECK(data3 == data4); } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) { data1 &= data2; @@ -1305,10 +1305,10 @@ namespace TEST(test_and_equals_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2)); CHECK((data1 & data2) == data3); } @@ -1316,16 +1316,16 @@ namespace //************************************************************************* TEST(test_or_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL); - constexpr etl::bitset<64, int64_t> data3 = data1 | data2; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 | data2; CHECK(data3 == data4); } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) { data1 |= data2; @@ -1334,10 +1334,10 @@ namespace TEST(test_or_equals_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2)); CHECK((data1 | data2) == data3); } @@ -1345,16 +1345,16 @@ namespace //************************************************************************* TEST(test_xor_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL); - constexpr etl::bitset<64, int64_t> data3 = data1 ^ data2; + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 ^ data2; CHECK(data3 == data4); } //************************************************************************* - constexpr etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) { data1 ^= data2; @@ -1363,10 +1363,10 @@ namespace TEST(test_xor_equals_operator) { - constexpr etl::bitset<64, int64_t> data1(0x12345678UL); - constexpr etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - constexpr etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2)); CHECK((data1 ^ data2) == data3); } @@ -1374,45 +1374,45 @@ namespace //************************************************************************* TEST(test_find_first) { - constexpr etl::bitset<8, int8_t> bs1(ull(0x00)); - constexpr size_t bs1fff = bs1.find_first(false); - constexpr size_t bs1fft = bs1.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false); + ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true); CHECK_EQUAL(0U, bs1fff); CHECK_EQUAL(etl::bitset<>::npos, bs1fft); - constexpr etl::bitset<8, int8_t> bs2(ull(0xFF)); - constexpr size_t bs2fff = bs2.find_first(false); - constexpr size_t bs2fft = bs2.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false); + ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true); CHECK_EQUAL(etl::bitset<>::npos, bs2fff); CHECK_EQUAL(0U, bs2fft); - constexpr etl::bitset<8, int8_t> bs3(ull(0x01)); - constexpr size_t bs3fff = bs3.find_first(false); - constexpr size_t bs3fft = bs3.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x01)); + ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false); + ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true); CHECK_EQUAL(1U, bs3fff); CHECK_EQUAL(0U, bs3fft); - constexpr etl::bitset<8, int8_t> bs4(ull(0x20)); - constexpr size_t bs4fff = bs4.find_first(false); - constexpr size_t bs4fft = bs4.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x20)); + ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false); + ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true); CHECK_EQUAL(0U, bs4fff); CHECK_EQUAL(5U, bs4fft); - constexpr etl::bitset<8, int8_t> bs5(ull(0x21)); - constexpr size_t bs5fff = bs5.find_first(false); - constexpr size_t bs5fft = bs5.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs5(ull(0x21)); + ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false); + ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true); CHECK_EQUAL(1U, bs5fff); CHECK_EQUAL(0U, bs5fft); - constexpr etl::bitset<8, int8_t> bs6(ull(0x0E)); - constexpr size_t bs6fff = bs6.find_first(false); - constexpr size_t bs6fft = bs6.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs6(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false); + ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true); CHECK_EQUAL(0U, bs6fff); CHECK_EQUAL(1U, bs6fft); - constexpr etl::bitset<8, int8_t> bs7(ull(0x31)); - constexpr size_t bs7fff = bs7.find_first(false); - constexpr size_t bs7fft = bs7.find_first(true); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs7(ull(0x31)); + ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false); + ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true); CHECK_EQUAL(1U, bs7fff); CHECK_EQUAL(0U, bs7fft); } @@ -1420,41 +1420,41 @@ namespace //************************************************************************* TEST(test_find_next) { - constexpr etl::bitset<8, int8_t> bs1(ull(0x00)); - constexpr size_t bs1fnf0 = bs1.find_next(false, 0); - constexpr size_t bs1fnf1 = bs1.find_next(false, 1); - constexpr size_t bs1fnt2 = bs1.find_next(true, 2); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1); + ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2); CHECK_EQUAL(0U, bs1fnf0); CHECK_EQUAL(1U, bs1fnf1); CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); - constexpr etl::bitset<8, int8_t> bs2(ull(0xFF)); - constexpr size_t bs2fnt0 = bs2.find_next(true, 0); - constexpr size_t bs2fnt1 = bs2.find_next(true, 1); - constexpr size_t bs2fnf2 = bs2.find_next(false, 2); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2); CHECK_EQUAL(0U, bs2fnt0); CHECK_EQUAL(1U, bs2fnt1); CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); - constexpr etl::bitset<8, int8_t> bs3(ull(0x0E)); - constexpr size_t bs3fnf0 = bs3.find_next(false, 0); - constexpr size_t bs3fnt1 = bs3.find_next(true, 1); - constexpr size_t bs3fnf2 = bs3.find_next(false, 2); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2); CHECK_EQUAL(0U, bs3fnf0); CHECK_EQUAL(1U, bs3fnt1); CHECK_EQUAL(4U, bs3fnf2); - constexpr etl::bitset<8, int8_t> bs4(ull(0x31)); - constexpr size_t bs4fnt0 = bs4.find_next(true, 0); - constexpr size_t bs4fnf0 = bs4.find_next(false, 0); - constexpr size_t bs4fnt1 = bs4.find_next(true, 1); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x31)); + ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1); CHECK_EQUAL(0U, bs4fnt0); CHECK_EQUAL(1U, bs4fnf0); CHECK_EQUAL(4U, bs4fnt1); } //************************************************************************* - constexpr std::pair, etl::bitset<8, int8_t>> test_swap_helper() + ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> test_swap_helper() { etl::bitset<8, int8_t> data1(ull(0x2A)); etl::bitset<8, int8_t> data2(ull(0x15)); @@ -1466,10 +1466,10 @@ namespace TEST(test_swap) { - constexpr etl::bitset<8, int8_t> compare1(0x2A); - constexpr etl::bitset<8, int8_t> compare2(0x15); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare1(0x2A); + ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare2(0x15); - constexpr std::pair, etl::bitset<8, int8_t>> swapped = test_swap_helper(); + ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> swapped = test_swap_helper(); CHECK(swapped.first == compare2); CHECK(swapped.second == compare1); @@ -1502,7 +1502,7 @@ namespace { using bs32 = etl::bitset<32, int32_t>; - constexpr bs32 b(0x12345678UL); + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::string<32> text = b.to_string('.', '*'); std::string stdtext = b.to_string('.', '*'); @@ -1517,7 +1517,7 @@ namespace { using bs32 = etl::bitset<32, int32_t>; - constexpr bs32 b(0x12345678UL); + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::wstring<32> text = b.to_string>(L'.', L'*'); std::wstring stdtext = b.to_string(L'.', L'*'); @@ -1531,7 +1531,7 @@ namespace { using bs32 = etl::bitset<32, int32_t>; - constexpr bs32 b(0x12345678UL); + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::u16string<32> text = b.to_string>(u'.', u'*'); std::u16string stdtext = b.to_string(u'.', u'*'); @@ -1545,7 +1545,7 @@ namespace { using bs32 = etl::bitset<32, int32_t>; - constexpr bs32 b(0x12345678UL); + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::u32string<32> text = b.to_string>(U'.', U'*'); std::u32string stdtext = b.to_string(U'.', U'*'); diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp index e19c15c9..2e0ecfdd 100644 --- a/test/test_bitset_new_ext_default_element_type.cpp +++ b/test/test_bitset_new_ext_default_element_type.cpp @@ -1802,13 +1802,13 @@ namespace etl::bitset_ext<64>::element_type buffer1[etl::bitset_ext<64>::Number_Of_Elements]; etl::bitset_ext<64>::element_type buffer2[etl::bitset_ext<64>::Number_Of_Elements]; - etl::bitset_ext<64> bs1(ull(0xC000'0000'0000'0031), buffer1); + etl::bitset_ext<64> bs1(ull(0xC000000000000031), buffer1); size_t bs1fnt1 = bs1.find_next(true, 10); size_t bs1fnt2 = bs1.find_next(true, 59); CHECK_EQUAL(62U, bs1fnt1); CHECK_EQUAL(62U, bs1fnt2); - etl::bitset_ext<64> bs2(ull(0x3FFF'FFFF'FFFF'FFCE), buffer2); + etl::bitset_ext<64> bs2(ull(0x3FFFFFFFFFFFFFCE), buffer2); size_t bs2fnf1 = bs2.find_next(false, 10); size_t bs2fnf2 = bs2.find_next(false, 59); CHECK_EQUAL(62U, bs2fnf1); diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp index fdfd64d4..2e5d77a1 100644 --- a/test/test_circular_iterator.cpp +++ b/test/test_circular_iterator.cpp @@ -31,8 +31,20 @@ SOFTWARE. #include #include +#include "etl/iterator.h" #include "etl/circular_iterator.h" +#if ETL_USING_STL + #if ETL_USING_CPP14 + #define ETL_OR_STD_R std + #else + // STL doesn't have rbegin() or rend() before C++14 + #define ETL_OR_STD_R etl + #endif +#else + #define ETL_OR_STD_R etl +#endif + namespace { using DataE = std::array; @@ -151,7 +163,7 @@ namespace { const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); CHECK(data.rbegin() == ci.begin()); CHECK(data.rend() == ci.end()); @@ -164,10 +176,10 @@ namespace { const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - DataL::const_reverse_iterator start = std::rbegin(data); + DataL::const_reverse_iterator start = ETL_OR_STD_R::rbegin(data); start++; - etl::circular_iterator ci(std::rbegin(data), std::rend(data), start); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data), start); CHECK(data.rbegin() == ci.begin()); CHECK(data.rend() == ci.end()); @@ -293,7 +305,7 @@ namespace const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 8, 7, 6, 5, 4, 3, 2, 1, 0, 9 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -307,7 +319,7 @@ namespace const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 8, 7, 6, 5, 4, 3, 2, 1, 0, 9 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -321,7 +333,7 @@ namespace const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -335,7 +347,7 @@ namespace const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -377,7 +389,7 @@ namespace const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -391,7 +403,7 @@ namespace const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -433,7 +445,7 @@ namespace const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { @@ -447,7 +459,7 @@ namespace const DataL data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; const DataE expected = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 }; - etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + etl::circular_iterator ci(ETL_OR_STD_R::rbegin(data), ETL_OR_STD_R::rend(data)); for (int i = 0; i < 20; ++i) { diff --git a/test/test_delegate.cpp b/test/test_delegate.cpp index 1a850941..5d30cacf 100644 --- a/test/test_delegate.cpp +++ b/test/test_delegate.cpp @@ -270,6 +270,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_constexpr_is_valid_false) { constexpr etl::delegate d; @@ -279,6 +280,7 @@ namespace CHECK_THROW(d(), etl::delegate_uninitialised); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_is_valid_true) @@ -301,6 +303,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_free_void_constexpr) { constexpr auto d = etl::delegate::create(); @@ -309,6 +312,7 @@ namespace CHECK(function_called == FunctionCalled::Free_Void_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_free_int) @@ -322,6 +326,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_free_int_constexpr) { constexpr auto d = etl::delegate::create(); @@ -331,6 +336,7 @@ namespace CHECK(function_called == FunctionCalled::Free_Int_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_free_reference) @@ -347,6 +353,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_free_reference_constexpr) { constexpr etl::delegate d = etl::delegate::create(); @@ -359,6 +366,7 @@ namespace CHECK(function_called == FunctionCalled::Free_Reference_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_free_moveableonly) @@ -375,6 +383,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_free_moveableonly_constexpr) { constexpr auto d = etl::delegate::create(); @@ -387,6 +396,7 @@ namespace CHECK(function_called == FunctionCalled::Free_Moveableonly_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_lambda_int) @@ -437,6 +447,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_operator_void_create_constexpr) { static Test test; @@ -447,6 +458,7 @@ namespace CHECK(function_called == FunctionCalled::Operator_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_operator_void_const) @@ -472,6 +484,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -480,6 +493,7 @@ namespace CHECK(function_called == FunctionCalled::Operator_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_const) @@ -492,6 +506,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_operator_void_compile_time_const_constexpr) { constexpr auto d = etl::delegate::create(); @@ -500,6 +515,7 @@ namespace CHECK(function_called == FunctionCalled::Operator_Const_Called); } +#endif #endif //************************************************************************* @@ -529,6 +545,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_void_constexpr) { static Test test; @@ -539,6 +556,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Void_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_void_const) @@ -553,6 +571,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_void_const_constexpr) { static const Test test; @@ -563,6 +582,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Void_Const_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_int) @@ -578,6 +598,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_int_constexpr) { static Test test; @@ -589,6 +610,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Int_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_int_const) @@ -604,6 +626,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_int_const_constexpr) { static const Test test; @@ -615,6 +638,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Int_Const_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_reference) @@ -632,6 +656,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_reference_constexpr) { static Test test; @@ -645,6 +670,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Reference_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_reference_const) @@ -662,6 +688,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_reference_const_constexpr) { static const Test test; @@ -675,6 +702,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Reference_Const_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_moveableonly) @@ -692,6 +720,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_moveableonly_constexpr) { static Test test; @@ -705,6 +734,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Moveableonly_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_static) @@ -721,6 +751,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_static_constexpr) { constexpr auto d = etl::delegate::create(); @@ -733,6 +764,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Static_Called); CHECK(parameter_correct); } +#endif #if !(defined(ETL_COMPILER_GCC) && (__GNUC__ <= 5)) //************************************************************************* @@ -746,6 +778,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_void_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -754,6 +787,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Void_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_void_const_compile_time) @@ -766,6 +800,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_void_const_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -774,6 +809,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Void_Const_Called); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_int_compile_time) @@ -787,6 +823,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_int_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -796,6 +833,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Int_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_int_const_compile_time) @@ -809,6 +847,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_int_const_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -818,6 +857,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Int_Const_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_reference_compile_time) @@ -834,6 +874,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_reference_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -846,6 +887,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Reference_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_member_reference_const_compile_time) @@ -862,6 +904,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_member_reference_const_compile_time_constexpr) { constexpr auto d = etl::delegate::create(); @@ -874,6 +917,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Reference_Const_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_set_free_int) @@ -983,6 +1027,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST_FIXTURE(SetupFixture, test_copy_construct_constexpr) { static Test test; @@ -995,6 +1040,7 @@ namespace CHECK(function_called == FunctionCalled::Member_Int_Called); CHECK(parameter_correct); } +#endif //************************************************************************* TEST_FIXTURE(SetupFixture, test_assignment) diff --git a/test/test_delegate_service.cpp b/test/test_delegate_service.cpp index 9fa36504..b68b1fa6 100644 --- a/test/test_delegate_service.cpp +++ b/test/test_delegate_service.cpp @@ -96,13 +96,13 @@ namespace Test test; // Callback for 'member2'. - constexpr Service::delegate_type member_callback = Service::delegate_type::create(); + ETL_CONSTEXPR14 Service::delegate_type member_callback = Service::delegate_type::create(); // Callback for 'global'. - constexpr Service::delegate_type global_callback = Service::delegate_type::create(); + ETL_CONSTEXPR14 Service::delegate_type global_callback = Service::delegate_type::create(); // Callback for 'unhandled'. - constexpr Service::delegate_type unhandled_callback = Service::delegate_type::create(); + ETL_CONSTEXPR14 Service::delegate_type unhandled_callback = Service::delegate_type::create(); //***************************************************************************** // Initialises the test results. diff --git a/test/test_delegate_service_compile_time.cpp b/test/test_delegate_service_compile_time.cpp index 002ceb8a..320a23be 100644 --- a/test/test_delegate_service_compile_time.cpp +++ b/test/test_delegate_service_compile_time.cpp @@ -85,15 +85,15 @@ namespace Test test; // Callback for 'member'. - constexpr etl::delegate member_callback = etl::delegate::create(); + ETL_CONSTEXPR14 etl::delegate member_callback = etl::delegate::create(); // Callback for 'global'. - constexpr etl::delegate global_callback = etl::delegate::create(); + ETL_CONSTEXPR14 etl::delegate global_callback = etl::delegate::create(); // Callback for 'unhandled'. - constexpr etl::delegate unhandled_callback = etl::delegate::create(); + ETL_CONSTEXPR14 etl::delegate unhandled_callback = etl::delegate::create(); - constexpr etl::delegate delegate_list[] + ETL_CONSTEXPR14 etl::delegate delegate_list[] { global_callback, member_callback, diff --git a/test/test_enum_type.cpp b/test/test_enum_type.cpp index 91893742..21e52d4f 100644 --- a/test/test_enum_type.cpp +++ b/test/test_enum_type.cpp @@ -62,6 +62,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_values) { constexpr enum_test zero = enum_test::ZERO; @@ -85,6 +86,7 @@ namespace CHECK_EQUAL(0, enum_zero2.get_value()); CHECK_EQUAL(std::string("ZERO"), std::string(string_zero)); } +#endif //************************************************************************* TEST(test_c_str) diff --git a/test/test_flags.cpp b/test/test_flags.cpp index b54a989d..acb33e7b 100644 --- a/test/test_flags.cpp +++ b/test/test_flags.cpp @@ -89,6 +89,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr) { constexpr Flags cef1; @@ -176,6 +177,7 @@ namespace CHECK(!is_not_same2); CHECK(!is_not_same3); } +#endif //************************************************************************* TEST(test_value_masked) diff --git a/test/test_format_spec.cpp b/test/test_format_spec.cpp index 2bcd75d8..eadf3ab0 100644 --- a/test/test_format_spec.cpp +++ b/test/test_format_spec.cpp @@ -92,6 +92,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_format_constexpr) { constexpr etl::format_spec format = etl::format_spec().base(16).boolalpha(true).fill('?').left().precision(6).show_base(true).upper_case(true).width(10); @@ -116,6 +117,7 @@ namespace CHECK_EQUAL(true, show_base); CHECK_EQUAL(true, upper_case); } +#endif }; } diff --git a/test/test_mem_cast_ptr.cpp b/test/test_mem_cast_ptr.cpp index 498cfe7e..6d1663a1 100644 --- a/test/test_mem_cast_ptr.cpp +++ b/test/test_mem_cast_ptr.cpp @@ -72,7 +72,7 @@ namespace return reinterpret_cast(uintptr_t(i)); } - std::aligned_storage_t buffer; + typename std::aligned_storage::type buffer; SUITE(test_mem_cast_ptr) { diff --git a/test/test_multiset.cpp b/test/test_multiset.cpp index 7e8b1851..7d197cde 100644 --- a/test/test_multiset.cpp +++ b/test/test_multiset.cpp @@ -712,7 +712,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); size_t compare_count = compare_data.erase(2); @@ -857,7 +857,7 @@ namespace using CSet = std::multiset>; const CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; const ESet data(initial_data.begin(), initial_data.end()); CHECK_EQUAL(compare_data.count(-1), data.count(Key(-1))); @@ -976,7 +976,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); ESet::iterator i_data = data.find(Key(0)); @@ -1069,7 +1069,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); ESet::const_iterator i_data = data.find(Key(0)); @@ -1176,7 +1176,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); CSet::iterator i_compare = compare_data.lower_bound(2); @@ -1233,7 +1233,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); CSet::const_iterator i_compare = compare_data.lower_bound(4); @@ -1290,7 +1290,7 @@ namespace using CSet = std::multiset>; CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); CSet::iterator i_compare = compare_data.upper_bound(1); @@ -1347,7 +1347,7 @@ namespace using CSet = std::multiset>; const CSet compare_data(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; const ESet data(initial_data.begin(), initial_data.end()); CSet::const_iterator i_compare = compare_data.upper_bound(3); @@ -1387,7 +1387,7 @@ namespace //************************************************************************* TEST_FIXTURE(SetupFixture, test_key_compare_using_transparent_comparator) { - using ESet = etl::multiset>; + using ESet = etl::multiset>; const ESet data(initial_data.begin(), initial_data.end()); ESet::key_compare compare = data.key_comp(); @@ -1483,7 +1483,7 @@ namespace using CSet = std::multiset>; CSet compare(initial_data.begin(), initial_data.end()); - using ESet = etl::multiset>; + using ESet = etl::multiset>; ESet data(initial_data.begin(), initial_data.end()); std::vector tab(test_data.begin(), test_data.end()); diff --git a/test/test_murmur3.cpp b/test/test_murmur3.cpp index 23c1b469..c8dc0d81 100644 --- a/test/test_murmur3.cpp +++ b/test/test_murmur3.cpp @@ -44,7 +44,7 @@ namespace //************************************************************************* TEST(test_murmur3_32_constructor) { - std::aligned_storage_t::value> storage[10]; + typename std::aligned_storage::value>::type storage[10]; std::string data("123456789"); char* begin = (char*)&storage[0]; @@ -61,7 +61,7 @@ namespace //************************************************************************* TEST(test_murmur3_32_add_values) { - std::aligned_storage_t::value> storage[10]; + typename std::aligned_storage::value>::type storage[10]; std::string data("123456789"); char* begin = (char*)&storage[0]; @@ -85,7 +85,7 @@ namespace //************************************************************************* TEST(test_murmur3_32_add_range) { - std::aligned_storage_t::value> storage[10]; + typename std::aligned_storage::value>::type storage[10]; std::string data("123456789"); char* begin = (char*)&storage[0]; diff --git a/test/test_string_view.cpp b/test/test_string_view.cpp index 9cf0e1e7..08c28a55 100644 --- a/test/test_string_view.cpp +++ b/test/test_string_view.cpp @@ -43,7 +43,10 @@ SOFTWARE. namespace { - typedef etl::string_view View; + using View = etl::string_view; + using WView = etl::wstring_view; + using U16View = etl::u16string_view; + using U32View = etl::u32string_view; etl::string<11> etltext = "Hello World"; std::string text = "Hello World"; @@ -54,16 +57,20 @@ namespace std::string text_shorter = "Hello Worl"; std::string text_different = "Goodbye!!!!"; - constexpr char cctext[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0' }; - constexpr wchar_t cwtext[] = { L'H', L'e', L'l', L'l', L'o', L' ', L'W', L'o', L'r', L'l', L'd', L'\0' }; + constexpr char cctext[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0' }; + constexpr wchar_t cwtext[] = { L'H', L'e', L'l', L'l', L'o', L' ', L'W', L'o', L'r', L'l', L'd', L'\0' }; constexpr char16_t cu16text[] = { u'H', u'e', u'l', u'l', u'o', u' ', u'W', u'o', u'r', u'l', u'd', u'\0' }; constexpr char32_t cu32text[] = { U'H', U'e', U'l', U'l', U'o', U' ', U'W', U'o', U'r', U'l', U'd', U'\0' }; - const char* pctext = cctext; + const char* pctext = cctext; + const wchar_t* pwtext = cwtext; + const char16_t* pu16text = cu16text; + const char32_t* pu32text = cu32text; SUITE(test_string_view) { //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr) { constexpr const char* text = "Hello"; @@ -83,6 +90,7 @@ namespace CHECK_ARRAY_EQUAL(text, str3, 5U); CHECK_ARRAY_EQUAL(text, str4, 5U); } +#endif //************************************************************************* TEST(test_default_constructor) @@ -95,9 +103,45 @@ namespace } //************************************************************************* - TEST(test_constructor_pointer_range) + TEST(test_constructor_pointer_range_char) { - View view(pctext, pctext + strlen(pctext)); + View view(pctext, pctext + etl::strlen(pctext)); + + CHECK(text.size() == view.size()); + CHECK(text.size() == view.max_size()); + + bool isEqual = std::equal(view.begin(), view.end(), text.begin()); + CHECK(isEqual); + } + + //************************************************************************* + TEST(test_constructor_pointer_range_wchar_t) + { + WView view(pwtext, pwtext + etl::strlen(pwtext)); + + CHECK(text.size() == view.size()); + CHECK(text.size() == view.max_size()); + + bool isEqual = std::equal(view.begin(), view.end(), text.begin()); + CHECK(isEqual); + } + + //************************************************************************* + TEST(test_constructor_pointer_range_u16char_t) + { + U16View view(pu16text, pu16text + etl::strlen(pu16text)); + + CHECK(text.size() == view.size()); + CHECK(text.size() == view.max_size()); + + bool isEqual = std::equal(view.begin(), view.end(), text.begin()); + CHECK(isEqual); + } + + //************************************************************************* + TEST(test_constructor_pointer_range_u32char_t) + { + U32View view(pu32text, pu32text + etl::strlen(pu32text)); CHECK(text.size() == view.size()); CHECK(text.size() == view.max_size()); @@ -169,6 +213,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_make_string_view) { constexpr auto cview = etl::make_string_view(cctext); @@ -181,6 +226,7 @@ namespace CHECK(std::equal(u16view.begin(), u16view.end(), text.begin())); CHECK(std::equal(u32view.begin(), u32view.end(), text.begin())); } +#endif //************************************************************************* TEST(test_make_string_view_check_consistent_strings_from_arrays_of_char) diff --git a/test/test_to_arithmetic.cpp b/test/test_to_arithmetic.cpp index d4695216..11b81fa2 100644 --- a/test/test_to_arithmetic.cpp +++ b/test/test_to_arithmetic.cpp @@ -1029,6 +1029,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_integral) { constexpr Text::const_pointer text{ STR("123") }; @@ -1038,6 +1039,7 @@ namespace CHECK_EQUAL(123, i); } +#endif } } diff --git a/test/test_to_arithmetic_u16.cpp b/test/test_to_arithmetic_u16.cpp index 6dd0e6e7..423c2f29 100644 --- a/test/test_to_arithmetic_u16.cpp +++ b/test/test_to_arithmetic_u16.cpp @@ -1006,6 +1006,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_integral) { constexpr Text::const_pointer text{ STR("123") }; @@ -1015,5 +1016,6 @@ namespace CHECK_EQUAL(123, i); } +#endif } } diff --git a/test/test_to_arithmetic_u32.cpp b/test/test_to_arithmetic_u32.cpp index 23474453..a53fb827 100644 --- a/test/test_to_arithmetic_u32.cpp +++ b/test/test_to_arithmetic_u32.cpp @@ -1006,6 +1006,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_integral) { constexpr Text::const_pointer text{ STR("123") }; @@ -1015,5 +1016,6 @@ namespace CHECK_EQUAL(123, i); } +#endif } } diff --git a/test/test_to_arithmetic_wchar_t.cpp b/test/test_to_arithmetic_wchar_t.cpp index 2754e1af..2842ea17 100644 --- a/test/test_to_arithmetic_wchar_t.cpp +++ b/test/test_to_arithmetic_wchar_t.cpp @@ -1006,6 +1006,7 @@ namespace } //************************************************************************* +#if ETL_USING_CPP14 TEST(test_constexpr_integral) { constexpr Text::const_pointer text{ STR("123") }; @@ -1015,5 +1016,6 @@ namespace CHECK_EQUAL(123, i); } +#endif } } diff --git a/test/test_unaligned_type_constexpr.cpp b/test/test_unaligned_type_constexpr.cpp index ddf65fa1..10164f60 100644 --- a/test/test_unaligned_type_constexpr.cpp +++ b/test/test_unaligned_type_constexpr.cpp @@ -31,6 +31,8 @@ SOFTWARE. #include "etl/unaligned_type.h" #include "etl/integral_limits.h" +#if ETL_USING_CPP14 + namespace { SUITE(test_unaligned_type_constexpr) @@ -638,3 +640,5 @@ namespace } }; } + +#endif \ No newline at end of file diff --git a/test/test_vector.cpp b/test/test_vector.cpp index aaa46997..bc5e5cf8 100644 --- a/test/test_vector.cpp +++ b/test/test_vector.cpp @@ -1379,7 +1379,7 @@ namespace { auto data = etl::make_vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); - using Type = std::remove_reference_t; + using Type = typename std::remove_reference::type; CHECK((std::is_same::value)); CHECK_EQUAL(0, data[0]); diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj index 01d70e22..73d77fe9 100644 --- a/test/vs2022/etl.vcxproj +++ b/test/vs2022/etl.vcxproj @@ -1185,6 +1185,7 @@ EditAndContinue /Zc:__cplusplus %(AdditionalOptions) true + Cpp17Support Console