From d884719098fb2ce1c284771a3a5c0ba2469c41d2 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Tue, 16 Dec 2025 09:15:26 +0000 Subject: [PATCH] Fixed all 'extra semicolon' warnings --- include/etl/atomic/atomic_gcc_sync.h | 8 +- include/etl/basic_string.h | 2 +- include/etl/bit.h | 2 +- include/etl/buffer_descriptors.h | 2 +- include/etl/byte.h | 2 +- include/etl/flat_map.h | 4 +- include/etl/intrusive_forward_list.h | 2 +- include/etl/intrusive_list.h | 4 +- include/etl/list.h | 2 +- include/etl/multimap.h | 4 +- include/etl/multiset.h | 4 +- include/etl/private/bitset_new.h | 4 +- include/etl/private/variant_legacy.h | 56 +- .../etl/private/variant_select_do_operator.h | 60 +- .../etl/private/variant_select_do_visitor.h | 60 +- include/etl/queue_lockable.h | 6 +- include/etl/queue_spsc_locked.h | 2 +- include/etl/reference_counted_object.h | 2 +- include/etl/rescale.h | 2 +- include/etl/set.h | 4 +- include/etl/to_arithmetic.h | 6 +- test/CMakeLists.txt | 6 + test/etl_profile.h | 2 +- test/murmurhash3.cpp | 6 +- test/syntax_check/CMakeLists.txt | 14 + test/test_algorithm.cpp | 2 +- test/test_alignment.cpp | 2 +- test/test_array.cpp | 2 +- test/test_array_view.cpp | 2 +- test/test_array_wrapper.cpp | 2 +- test/test_atomic.cpp | 6 +- test/test_base64_RFC2152_decoder.cpp | 2 +- test/test_base64_RFC2152_encoder.cpp | 2 +- test/test_base64_RFC3501_decoder.cpp | 2 +- test/test_base64_RFC3501_encoder.cpp | 2 +- ...64_RFC4648_URL_decoder_with_no_padding.cpp | 2 +- ...ase64_RFC4648_URL_decoder_with_padding.cpp | 2 +- ...64_RFC4648_URL_encoder_with_no_padding.cpp | 2 +- ...ase64_RFC4648_URL_encoder_with_padding.cpp | 2 +- ...base64_RFC4648_decoder_with_no_padding.cpp | 2 +- ...st_base64_RFC4648_decoder_with_padding.cpp | 2 +- ...base64_RFC4648_encoder_with_no_padding.cpp | 2 +- ...st_base64_RFC4648_encoder_with_padding.cpp | 2 +- test/test_binary.cpp | 2 +- test/test_bip_buffer_spsc_atomic.cpp | 2 +- test/test_bit.cpp | 2 +- test/test_bit_stream.cpp | 2 +- test/test_bit_stream_reader_big_endian.cpp | 2 +- test/test_bit_stream_reader_little_endian.cpp | 2 +- test/test_bit_stream_writer_big_endian.cpp | 2 +- test/test_bit_stream_writer_little_endian.cpp | 2 +- test/test_bitset_legacy.cpp | 2 +- test/test_bitset_new_comparisons.cpp | 2 +- test/test_bitset_new_default_element_type.cpp | 2 +- ...itset_new_explicit_single_element_type.cpp | 2 +- ...st_bitset_new_ext_default_element_type.cpp | 2 +- ...t_new_ext_explicit_single_element_type.cpp | 2 +- test/test_bloom_filter.cpp | 2 +- test/test_bresenham_line.cpp | 2 +- test/test_bsd_checksum.cpp | 2 +- test/test_buffer_descriptors.cpp | 2 +- test/test_byte_stream.cpp | 2 +- test/test_callback_service.cpp | 2 +- test/test_callback_timer.cpp | 2 +- test/test_callback_timer_atomic.cpp | 2 +- test/test_callback_timer_deferred_locked.cpp | 2 +- test/test_callback_timer_interrupt.cpp | 2 +- test/test_callback_timer_locked.cpp | 2 +- test/test_char_traits.cpp | 2 +- test/test_checksum.cpp | 2 +- test/test_chrono_clocks.cpp | 2 +- test/test_chrono_day.cpp | 2 +- test/test_chrono_duration.cpp | 2 +- test/test_chrono_hh_mm_ss.cpp | 2 +- test/test_chrono_literals.cpp | 2 +- test/test_chrono_month.cpp | 2 +- test/test_chrono_month_day.cpp | 3 +- test/test_chrono_month_day_last.cpp | 2 +- test/test_chrono_month_weekday.cpp | 2 +- test/test_chrono_month_weekday_last.cpp | 2 +- test/test_chrono_operators.cpp | 2 +- test/test_chrono_time_point.cpp | 2 +- test/test_chrono_weekday.cpp | 2 +- test/test_chrono_weekday_indexed.cpp | 2 +- test/test_chrono_weekday_last.cpp | 2 +- test/test_chrono_year.cpp | 2 +- test/test_chrono_year_month.cpp | 2 +- test/test_chrono_year_month_day.cpp | 2 +- test/test_chrono_year_month_day_last.cpp | 2 +- test/test_chrono_year_month_weekday.cpp | 2 +- test/test_chrono_year_month_weekday_last.cpp | 2 +- test/test_circular_buffer.cpp | 7 +- test/test_circular_buffer_external_buffer.cpp | 2 +- test/test_circular_iterator.cpp | 2 +- test/test_closure.cpp | 2 +- test/test_closure_constexpr.cpp | 2 +- test/test_compare.cpp | 2 +- test/test_const_map.cpp | 6 +- test/test_const_map_constexpr.cpp | 6 +- test/test_const_map_ext.cpp | 6 +- test/test_const_map_ext_constexpr.cpp | 6 +- test/test_const_multimap.cpp | 6 +- test/test_const_multimap_constexpr.cpp | 6 +- test/test_const_multimap_ext.cpp | 6 +- test/test_const_multimap_ext_constexpr.cpp | 6 +- test/test_const_multiset.cpp | 6 +- test/test_const_multiset_constexpr.cpp | 6 +- test/test_const_multiset_ext.cpp | 6 +- test/test_const_multiset_ext_constexpr.cpp | 6 +- test/test_const_set.cpp | 4 +- test/test_const_set_constexpr.cpp | 10 +- test/test_const_set_ext.cpp | 6 +- test/test_const_set_ext_constexpr.cpp | 6 +- test/test_constant.cpp | 2 +- test/test_container.cpp | 2 +- test/test_correlation.cpp | 2 +- test/test_covariance.cpp | 2 +- test/test_crc1.cpp | 2 +- test/test_crc16.cpp | 2 +- test/test_crc16_a.cpp | 2 +- test/test_crc16_arc.cpp | 2 +- test/test_crc16_aug_ccitt.cpp | 2 +- test/test_crc16_buypass.cpp | 2 +- test/test_crc16_ccitt.cpp | 2 +- test/test_crc16_cdma2000.cpp | 2 +- test/test_crc16_dds110.cpp | 2 +- test/test_crc16_dectr.cpp | 2 +- test/test_crc16_dectx.cpp | 2 +- test/test_crc16_dnp.cpp | 2 +- test/test_crc16_en13757.cpp | 2 +- test/test_crc16_genibus.cpp | 2 +- test/test_crc16_kermit.cpp | 2 +- test/test_crc16_m17.cpp | 2 +- test/test_crc16_maxim.cpp | 2 +- test/test_crc16_mcrf4xx.cpp | 2 +- test/test_crc16_modbus.cpp | 2 +- test/test_crc16_opensafety_a.cpp | 2 +- test/test_crc16_opensafety_b.cpp | 2 +- test/test_crc16_profibus.cpp | 2 +- test/test_crc16_riello.cpp | 2 +- test/test_crc16_t10dif.cpp | 2 +- test/test_crc16_teledisk.cpp | 2 +- test/test_crc16_tms37157.cpp | 2 +- test/test_crc16_usb.cpp | 2 +- test/test_crc16_x25.cpp | 2 +- test/test_crc16_xmodem.cpp | 2 +- test/test_crc32.cpp | 2 +- test/test_crc32_bzip2.cpp | 2 +- test/test_crc32_c.cpp | 2 +- test/test_crc32_d.cpp | 2 +- test/test_crc32_jamcrc.cpp | 2 +- test/test_crc32_mpeg2.cpp | 2 +- test/test_crc32_posix.cpp | 2 +- test/test_crc32_q.cpp | 2 +- test/test_crc32_xfer.cpp | 2 +- test/test_crc64_ecma.cpp | 2 +- test/test_crc64_iso.cpp | 2 +- test/test_crc8_ccitt.cpp | 2 +- test/test_crc8_cdma2000.cpp | 2 +- test/test_crc8_darc.cpp | 2 +- test/test_crc8_dvbs2.cpp | 2 +- test/test_crc8_ebu.cpp | 2 +- test/test_crc8_icode.cpp | 2 +- test/test_crc8_itu.cpp | 2 +- test/test_crc8_j1850.cpp | 2 +- test/test_crc8_j1850_zero.cpp | 2 +- test/test_crc8_maxim.cpp | 2 +- test/test_crc8_nrsc5.cpp | 2 +- test/test_crc8_opensafety.cpp | 2 +- test/test_crc8_rohc.cpp | 2 +- test/test_crc8_wcdma.cpp | 2 +- test/test_cyclic_value.cpp | 2 +- test/test_debounce.cpp | 2 +- test/test_delegate.cpp | 6 +- test/test_delegate_cpp03.cpp | 4 +- test/test_delegate_observable.cpp | 2 +- test/test_delegate_service.cpp | 2 +- test/test_delegate_service_compile_time.cpp | 2 +- test/test_delegate_service_cpp03.cpp | 2 +- test/test_deque.cpp | 2 +- test/test_endian.cpp | 2 +- test/test_enum_type.cpp | 2 +- test/test_error_handler.cpp | 2 +- test/test_etl_assert.cpp | 2 +- test/test_etl_traits.cpp | 2 +- test/test_exception.cpp | 2 +- test/test_expected.cpp | 2 +- test/test_fixed_iterator.cpp | 2 +- test/test_flags.cpp | 2 +- test/test_flat_map.cpp | 2 +- test/test_flat_multimap.cpp | 2 +- test/test_flat_multiset.cpp | 2 +- test/test_flat_set.cpp | 2 +- test/test_fnv_1.cpp | 2 +- test/test_format_spec.cpp | 2 +- test/test_forward_list.cpp | 2 +- test/test_forward_list_shared_pool.cpp | 2 +- test/test_fsm.cpp | 2 +- test/test_function.cpp | 2 +- test/test_function_traits.cpp | 4 +- test/test_functional.cpp | 2 +- test/test_gamma.cpp | 2 +- test/test_hash.cpp | 2 +- test/test_hfsm.cpp | 2 +- ...t_hfsm_recurse_to_inner_state_on_start.cpp | 2 +- test/test_histogram.cpp | 2 +- test/test_indirect_vector.cpp | 2 +- test/test_indirect_vector_external_buffer.cpp | 2 +- test/test_instance_count.cpp | 2 +- test/test_integral_limits.cpp | 2 +- test/test_intrusive_forward_list.cpp | 2 +- test/test_intrusive_links.cpp | 2 +- test/test_intrusive_list.cpp | 2 +- test/test_intrusive_queue.cpp | 2 +- test/test_intrusive_stack.cpp | 2 +- test/test_invert.cpp | 2 +- test/test_io_port.cpp | 2 +- test/test_iterator.cpp | 2 +- test/test_jenkins.cpp | 2 +- test/test_largest.cpp | 2 +- test/test_limiter.cpp | 2 +- test/test_limits.cpp | 2 +- test/test_list.cpp | 2 +- test/test_list_shared_pool.cpp | 2 +- test/test_macros.cpp | 2 +- test/test_make_string.cpp | 8 +- test/test_map.cpp | 2 +- test/test_math.cpp | 2 +- test/test_math_functions.cpp | 2 +- test/test_mean.cpp | 2 +- test/test_mem_cast.cpp | 2 +- test/test_mem_cast_ptr.cpp | 2 +- test/test_memory.cpp | 4 +- test/test_message.cpp | 2 +- test/test_message_broker.cpp | 2 +- test/test_message_bus.cpp | 2 +- test/test_message_packet.cpp | 2 +- test/test_message_router.cpp | 2 +- test/test_message_router_registry.cpp | 2 +- test/test_message_timer.cpp | 2 +- test/test_message_timer_atomic.cpp | 2 +- test/test_message_timer_interrupt.cpp | 2 +- test/test_message_timer_locked.cpp | 2 +- test/test_multi_array.cpp | 2 +- test/test_multi_range.cpp | 2 +- test/test_multi_span.cpp | 2 +- test/test_multi_vector.cpp | 2 +- test/test_multimap.cpp | 2 +- test/test_multiset.cpp | 2 +- test/test_murmur3.cpp | 2 +- test/test_not_null_pointer.cpp | 2 +- test/test_not_null_pointer_constexpr.cpp | 2 +- test/test_numeric.cpp | 2 +- test/test_optional.cpp | 2 +- test/test_overload.cpp | 2 +- test/test_parameter_pack.cpp | 2 +- test/test_parameter_type.cpp | 2 +- test/test_parity_checksum.cpp | 2 +- test/test_pearson.cpp | 2 +- test/test_pool.cpp | 794 +++++----- test/test_priority_queue.cpp | 2 +- test/test_pseudo_moving_average.cpp | 2 +- test/test_quantize.cpp | 2 +- test/test_queue.cpp | 2 +- test/test_queue_lockable.cpp | 2 +- test/test_queue_lockable_small.cpp | 2 +- test/test_queue_memory_model_small.cpp | 2 +- test/test_queue_mpmc_mutex.cpp | 8 +- test/test_queue_mpmc_mutex_small.cpp | 8 +- test/test_queue_spsc_atomic.cpp | 2 +- test/test_queue_spsc_atomic_small.cpp | 2 +- test/test_queue_spsc_isr.cpp | 2 +- test/test_queue_spsc_isr_small.cpp | 2 +- test/test_queue_spsc_locked.cpp | 2 +- test/test_queue_spsc_locked_small.cpp | 2 +- test/test_random.cpp | 3 +- test/test_ratio.cpp | 3 +- test/test_reference_flat_map.cpp | 2 +- test/test_reference_flat_multimap.cpp | 2 +- test/test_reference_flat_multiset.cpp | 2 +- test/test_reference_flat_set.cpp | 2 +- test/test_rescale.cpp | 2 +- test/test_result.cpp | 2 +- test/test_rms.cpp | 2 +- test/test_rounded_integral_division.cpp | 2 +- test/test_scaled_rounding.cpp | 2 +- test/test_set.cpp | 2 +- test/test_smallest.cpp | 2 +- test/test_span_dynamic_extent.cpp | 2 +- test/test_span_fixed_extent.cpp | 2 +- test/test_stack.cpp | 2 +- test/test_standard_deviation.cpp | 2 +- test/test_state_chart.cpp | 2 +- test/test_state_chart_compile_time.cpp | 2 +- ...chart_compile_time_with_data_parameter.cpp | 2 +- test/test_state_chart_with_data_parameter.cpp | 2 +- ...state_chart_with_rvalue_data_parameter.cpp | 2 +- test/test_string_char.cpp | 2 +- test/test_string_char_external_buffer.cpp | 2 +- test/test_string_stream.cpp | 2 +- test/test_string_stream_u16.cpp | 2 +- test/test_string_stream_u32.cpp | 2 +- test/test_string_stream_u8.cpp | 2 +- test/test_string_stream_wchar_t.cpp | 2 +- test/test_string_u16.cpp | 2 +- test/test_string_u16_external_buffer.cpp | 2 +- test/test_string_u32.cpp | 2 +- test/test_string_u32_external_buffer.cpp | 2 +- test/test_string_u8.cpp | 2 +- test/test_string_u8_external_buffer.cpp | 2 +- test/test_string_utilities.cpp | 2 +- test/test_string_utilities_std.cpp | 2 +- test/test_string_utilities_std_u16.cpp | 2 +- test/test_string_utilities_std_u32.cpp | 2 +- test/test_string_utilities_std_u8.cpp | 2 +- test/test_string_utilities_std_wchar_t.cpp | 2 +- test/test_string_utilities_u16.cpp | 2 +- test/test_string_utilities_u32.cpp | 2 +- test/test_string_utilities_u8.cpp | 2 +- test/test_string_utilities_wchar_t.cpp | 2 +- test/test_string_view.cpp | 2 +- test/test_string_wchar_t.cpp | 2 +- test/test_string_wchar_t_external_buffer.cpp | 2 +- test/test_task_scheduler.cpp | 2 +- test/test_threshold.cpp | 2 +- test/test_to_string.cpp | 2 +- test/test_to_u16string.cpp | 2 +- test/test_to_u32string.cpp | 2 +- test/test_to_u8string.cpp | 2 +- test/test_to_wstring.cpp | 2 +- test/test_type_def.cpp | 2 +- test/test_type_list.cpp | 2 +- test/test_type_lookup.cpp | 2 +- test/test_type_select.cpp | 2 +- test/test_type_traits.cpp | 1304 ++++++++--------- test/test_unaligned_type.cpp | 2 +- test/test_unaligned_type_ext.cpp | 2 +- test/test_uncopyable.cpp | 2 +- test/test_unordered_map.cpp | 2 +- test/test_unordered_multimap.cpp | 2 +- test/test_unordered_multiset.cpp | 2 +- test/test_unordered_set.cpp | 2 +- test/test_user_type.cpp | 14 +- test/test_utility.cpp | 56 +- test/test_variance.cpp | 2 +- test/test_variant_legacy.cpp | 2 +- test/test_variant_pool.cpp | 2 +- test/test_variant_pool_external_buffer.cpp | 2 +- test/test_variant_variadic.cpp | 2 +- test/test_vector.cpp | 2 +- test/test_vector_external_buffer.cpp | 2 +- test/test_vector_non_trivial.cpp | 2 +- test/test_vector_pointer.cpp | 2 +- test/test_vector_pointer_external_buffer.cpp | 2 +- test/test_xor_checksum.cpp | 2 +- test/test_xor_rotate_checksum.cpp | 2 +- test/vs2022/etl.vcxproj.filters | 6 +- 357 files changed, 1609 insertions(+), 1591 deletions(-) diff --git a/include/etl/atomic/atomic_gcc_sync.h b/include/etl/atomic/atomic_gcc_sync.h index 67c7c8bf..de7b8d5a 100644 --- a/include/etl/atomic/atomic_gcc_sync.h +++ b/include/etl/atomic/atomic_gcc_sync.h @@ -75,8 +75,8 @@ namespace etl { #if defined(ETL_USE_ATOMIC_BUILTINS) -#define ETL_BUILTIN_LOCK while (__atomic_test_and_set(&flag, etl::memory_order_seq_cst)) {} -#define ETL_BUILTIN_UNLOCK __atomic_clear(&flag, etl::memory_order_seq_cst); +#define ETL_BUILTIN_LOCK do { while (__atomic_test_and_set(&flag, etl::memory_order_seq_cst)) {} } while (0) +#define ETL_BUILTIN_UNLOCK do { __atomic_clear(&flag, etl::memory_order_seq_cst); } while (0) //*************************************************************************** // Atomic type for pre C++11 GCC compilers that support the builtin '__atomic' functions. @@ -1021,8 +1021,8 @@ namespace etl #if defined(ETL_USE_SYNC_BUILTINS) -#define ETL_BUILTIN_LOCK while (__sync_lock_test_and_set(&flag, 1U)) {} -#define ETL_BUILTIN_UNLOCK __sync_lock_release(&flag); +#define ETL_BUILTIN_LOCK do { while (__sync_lock_test_and_set(&flag, 1U)) {} } while(0) +#define ETL_BUILTIN_UNLOCK do { __sync_lock_release(&flag); } while(0) //*************************************************************************** // Atomic type for pre C++11 GCC compilers that support the builtin '__sync' functions. diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h index 9a39b078..d98adf1b 100644 --- a/include/etl/basic_string.h +++ b/include/etl/basic_string.h @@ -1015,7 +1015,7 @@ namespace etl ETL_ASSERT_FAIL(ETL_ERROR(string_truncation)); #endif #endif - return to_iterator(position);; + return to_iterator(position); } // Fills the string to the end? diff --git a/include/etl/bit.h b/include/etl/bit.h index eb7d5817..d8b6c2e6 100644 --- a/include/etl/bit.h +++ b/include/etl/bit.h @@ -138,7 +138,7 @@ namespace etl typename etl::enable_if::value, int>::type countr_one(T value) ETL_NOEXCEPT { - return etl::count_trailing_ones(value);; + return etl::count_trailing_ones(value); } diff --git a/include/etl/buffer_descriptors.h b/include/etl/buffer_descriptors.h index b34e223b..02ff32a9 100644 --- a/include/etl/buffer_descriptors.h +++ b/include/etl/buffer_descriptors.h @@ -147,7 +147,7 @@ namespace etl //********************************* void allocate() { - pdesc_item->in_use = true;; + pdesc_item->in_use = true; } /// The pointer to the buffer descriptor. diff --git a/include/etl/byte.h b/include/etl/byte.h index 51528288..ae10af77 100644 --- a/include/etl/byte.h +++ b/include/etl/byte.h @@ -76,7 +76,7 @@ namespace etl typename etl::enable_if::value, etl::byte&>::type operator <<=(etl::byte& b, TInteger shift) ETL_NOEXCEPT { - return b = b << shift;; + return b = b << shift; } //************************************************************************* diff --git a/include/etl/flat_map.h b/include/etl/flat_map.h index c57856a8..0bb1d552 100644 --- a/include/etl/flat_map.h +++ b/include/etl/flat_map.h @@ -606,7 +606,7 @@ namespace etl i_element->~value_type(); storage.release(etl::addressof(*i_element)); refmap_t::erase(i_element); - ETL_DECREMENT_DEBUG_COUNT;; + ETL_DECREMENT_DEBUG_COUNT; return 1; } } @@ -627,7 +627,7 @@ namespace etl i_element->~value_type(); storage.release(etl::addressof(*i_element)); refmap_t::erase(i_element); - ETL_DECREMENT_DEBUG_COUNT;; + ETL_DECREMENT_DEBUG_COUNT; return 1; } } diff --git a/include/etl/intrusive_forward_list.h b/include/etl/intrusive_forward_list.h index 262c8052..210dd542 100644 --- a/include/etl/intrusive_forward_list.h +++ b/include/etl/intrusive_forward_list.h @@ -1165,7 +1165,7 @@ namespace etl link_type* before = &this->start; link_type* before_next = get_next(before); - link_type* terminal = &this->terminator;; + link_type* terminal = &this->terminator; while ((before->etl_next != terminal) && (other_begin != other_terminal)) { diff --git a/include/etl/intrusive_list.h b/include/etl/intrusive_list.h index 36f3966d..7a6d057b 100644 --- a/include/etl/intrusive_list.h +++ b/include/etl/intrusive_list.h @@ -259,7 +259,7 @@ namespace etl //************************************************************************* bool contains_node(const link_type& search_link) const { - return is_link_in_list(&search_link);; + return is_link_in_list(&search_link); } //************************************************************************* @@ -268,7 +268,7 @@ namespace etl //************************************************************************* bool contains_node(const link_type* search_link) const { - return is_link_in_list(search_link);; + return is_link_in_list(search_link); } protected: diff --git a/include/etl/list.h b/include/etl/list.h index ea070c0e..63ab9fc3 100644 --- a/include/etl/list.h +++ b/include/etl/list.h @@ -1839,7 +1839,7 @@ namespace etl { ETL_ASSERT(p_node_pool != ETL_NULLPTR, ETL_ERROR(list_no_pool)); p_node_pool->release_all(); - ETL_RESET_DEBUG_COUNT;; + ETL_RESET_DEBUG_COUNT; } else { diff --git a/include/etl/multimap.h b/include/etl/multimap.h index 59f0d001..f585e45d 100644 --- a/include/etl/multimap.h +++ b/include/etl/multimap.h @@ -1490,7 +1490,7 @@ namespace etl key_compare key_comp() const { return kcompare; - }; + } //************************************************************************* /// How to compare two value elements. @@ -1498,7 +1498,7 @@ namespace etl value_compare value_comp() const { return vcompare; - }; + } //************************************************************************* /// Check if the map contains the key. diff --git a/include/etl/multiset.h b/include/etl/multiset.h index a44fe751..de020d28 100644 --- a/include/etl/multiset.h +++ b/include/etl/multiset.h @@ -1478,7 +1478,7 @@ namespace etl key_compare key_comp() const { return compare; - }; + } //************************************************************************* /// How to compare two value elements. @@ -1486,7 +1486,7 @@ namespace etl value_compare value_comp() const { return compare; - }; + } //************************************************************************* /// Check if the set contains the key. diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index e7673f4b..6d67a390 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -1231,7 +1231,7 @@ namespace etl void reset_position(pointer pbuffer, size_t position) ETL_NOEXCEPT { - const size_t index = position >> etl::log2::value;; + const size_t index = position >> etl::log2::value; const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); pbuffer[index] &= ~bit; @@ -1454,7 +1454,7 @@ namespace etl void flip_position(pointer pbuffer, size_t position) ETL_NOEXCEPT { - const size_t index = position >> etl::log2::value;; + const size_t index = position >> etl::log2::value; const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); pbuffer[index] ^= bit; diff --git a/include/etl/private/variant_legacy.h b/include/etl/private/variant_legacy.h index a53e3602..e6c01156 100644 --- a/include/etl/private/variant_legacy.h +++ b/include/etl/private/variant_legacy.h @@ -285,7 +285,7 @@ namespace etl private: - void read(no_type8&) {}; + void read(no_type8&) {} }; //************************************************************************* @@ -311,8 +311,8 @@ namespace etl private: - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type7&) {} + void read(no_type8&) {} }; //************************************************************************* @@ -337,9 +337,9 @@ namespace etl private: - void read(no_type6&) {}; - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type6&) {} + void read(no_type7&) {} + void read(no_type8&) {} }; //************************************************************************* @@ -363,10 +363,10 @@ namespace etl private: - void read(no_type5&) {}; - void read(no_type6&) {}; - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type5&) {} + void read(no_type6&) {} + void read(no_type7&) {} + void read(no_type8&) {} }; //************************************************************************* @@ -389,11 +389,11 @@ namespace etl private: - void read(no_type4&) {}; - void read(no_type5&) {}; - void read(no_type6&) {}; - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type4&) {} + void read(no_type5&) {} + void read(no_type6&) {} + void read(no_type7&) {} + void read(no_type8&) {} }; //************************************************************************* @@ -415,12 +415,12 @@ namespace etl private: - void read(no_type3&) {}; - void read(no_type4&) {}; - void read(no_type5&) {}; - void read(no_type6&) {}; - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type3&) {} + void read(no_type4&) {} + void read(no_type5&) {} + void read(no_type6&) {} + void read(no_type7&) {} + void read(no_type8&) {} }; //************************************************************************* @@ -441,13 +441,13 @@ namespace etl private: - void read(no_type2&) {}; - void read(no_type3&) {}; - void read(no_type4&) {}; - void read(no_type5&) {}; - void read(no_type6&) {}; - void read(no_type7&) {}; - void read(no_type8&) {}; + void read(no_type2&) {} + void read(no_type3&) {} + void read(no_type4&) {} + void read(no_type5&) {} + void read(no_type6&) {} + void read(no_type7&) {} + void read(no_type8&) {} }; //*************************************************************************** diff --git a/include/etl/private/variant_select_do_operator.h b/include/etl/private/variant_select_do_operator.h index c4b125d0..d16f1fe3 100644 --- a/include/etl/private/variant_select_do_operator.h +++ b/include/etl/private/variant_select_do_operator.h @@ -84,7 +84,7 @@ namespace private_variant case 2: { visitor(etl::get<2>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -102,7 +102,7 @@ namespace private_variant case 3: { visitor(etl::get<3>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -121,7 +121,7 @@ namespace private_variant case 4: { visitor(etl::get<4>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -141,7 +141,7 @@ namespace private_variant case 5: { visitor(etl::get<5>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -162,7 +162,7 @@ namespace private_variant case 6: { visitor(etl::get<6>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -184,7 +184,7 @@ namespace private_variant case 7: { visitor(etl::get<7>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES) //*************************************************************************** @@ -207,7 +207,7 @@ namespace private_variant case 8: { visitor(etl::get<8>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -231,7 +231,7 @@ namespace private_variant case 9: { visitor(etl::get<9>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -256,7 +256,7 @@ namespace private_variant case 10: { visitor(etl::get<10>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -282,7 +282,7 @@ namespace private_variant case 11: { visitor(etl::get<11>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -309,7 +309,7 @@ namespace private_variant case 12: { visitor(etl::get<12>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -337,7 +337,7 @@ namespace private_variant case 13: { visitor(etl::get<13>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -366,7 +366,7 @@ namespace private_variant case 14: { visitor(etl::get<14>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -396,7 +396,7 @@ namespace private_variant case 15: { visitor(etl::get<15>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES) //*************************************************************************** @@ -427,7 +427,7 @@ namespace private_variant case 16: { visitor(etl::get<16>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -459,7 +459,7 @@ namespace private_variant case 17: { visitor(etl::get<17>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -492,7 +492,7 @@ namespace private_variant case 18: { visitor(etl::get<18>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -526,7 +526,7 @@ namespace private_variant case 19: { visitor(etl::get<19>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -561,7 +561,7 @@ namespace private_variant case 20: { visitor(etl::get<20>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -597,7 +597,7 @@ namespace private_variant case 21: { visitor(etl::get<21>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -634,7 +634,7 @@ namespace private_variant case 22: { visitor(etl::get<22>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -672,7 +672,7 @@ namespace private_variant case 23: { visitor(etl::get<23>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES) //*************************************************************************** @@ -711,7 +711,7 @@ namespace private_variant case 24: { visitor(etl::get<24>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -751,7 +751,7 @@ namespace private_variant case 25: { visitor(etl::get<25>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -792,7 +792,7 @@ namespace private_variant case 26: { visitor(etl::get<26>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -834,7 +834,7 @@ namespace private_variant case 27: { visitor(etl::get<27>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -877,7 +877,7 @@ namespace private_variant case 28: { visitor(etl::get<28>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -921,7 +921,7 @@ namespace private_variant case 29: { visitor(etl::get<29>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -966,7 +966,7 @@ namespace private_variant case 30: { visitor(etl::get<30>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -1012,7 +1012,7 @@ namespace private_variant case 31: { visitor(etl::get<31>(the_variant)); break; } default: break; } - }; + } }; #endif #endif diff --git a/include/etl/private/variant_select_do_visitor.h b/include/etl/private/variant_select_do_visitor.h index b6e5bc50..e1a5bbbd 100644 --- a/include/etl/private/variant_select_do_visitor.h +++ b/include/etl/private/variant_select_do_visitor.h @@ -84,7 +84,7 @@ namespace private_variant case 2: { visitor.visit(etl::get<2>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -102,7 +102,7 @@ namespace private_variant case 3: { visitor.visit(etl::get<3>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -121,7 +121,7 @@ namespace private_variant case 4: { visitor.visit(etl::get<4>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -141,7 +141,7 @@ namespace private_variant case 5: { visitor.visit(etl::get<5>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -162,7 +162,7 @@ namespace private_variant case 6: { visitor.visit(etl::get<6>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -184,7 +184,7 @@ namespace private_variant case 7: { visitor.visit(etl::get<7>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES) //*************************************************************************** @@ -207,7 +207,7 @@ namespace private_variant case 8: { visitor.visit(etl::get<8>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -231,7 +231,7 @@ namespace private_variant case 9: { visitor.visit(etl::get<9>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -256,7 +256,7 @@ namespace private_variant case 10: { visitor.visit(etl::get<10>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -282,7 +282,7 @@ namespace private_variant case 11: { visitor.visit(etl::get<11>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -309,7 +309,7 @@ namespace private_variant case 12: { visitor.visit(etl::get<12>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -337,7 +337,7 @@ namespace private_variant case 13: { visitor.visit(etl::get<13>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -366,7 +366,7 @@ namespace private_variant case 14: { visitor.visit(etl::get<14>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -396,7 +396,7 @@ namespace private_variant case 15: { visitor.visit(etl::get<15>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES) //*************************************************************************** @@ -427,7 +427,7 @@ namespace private_variant case 16: { visitor.visit(etl::get<16>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -459,7 +459,7 @@ namespace private_variant case 17: { visitor.visit(etl::get<17>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -492,7 +492,7 @@ namespace private_variant case 18: { visitor.visit(etl::get<18>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -526,7 +526,7 @@ namespace private_variant case 19: { visitor.visit(etl::get<19>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -561,7 +561,7 @@ namespace private_variant case 20: { visitor.visit(etl::get<20>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -597,7 +597,7 @@ namespace private_variant case 21: { visitor.visit(etl::get<21>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -634,7 +634,7 @@ namespace private_variant case 22: { visitor.visit(etl::get<22>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -672,7 +672,7 @@ namespace private_variant case 23: { visitor.visit(etl::get<23>(the_variant)); break; } default: break; } - }; + } }; #if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES) //*************************************************************************** @@ -711,7 +711,7 @@ namespace private_variant case 24: { visitor.visit(etl::get<24>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -751,7 +751,7 @@ namespace private_variant case 25: { visitor.visit(etl::get<25>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -792,7 +792,7 @@ namespace private_variant case 26: { visitor.visit(etl::get<26>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -834,7 +834,7 @@ namespace private_variant case 27: { visitor.visit(etl::get<27>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -877,7 +877,7 @@ namespace private_variant case 28: { visitor.visit(etl::get<28>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -921,7 +921,7 @@ namespace private_variant case 29: { visitor.visit(etl::get<29>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -966,7 +966,7 @@ namespace private_variant case 30: { visitor.visit(etl::get<30>(the_variant)); break; } default: break; } - }; + } }; //*************************************************************************** @@ -1012,7 +1012,7 @@ namespace private_variant case 31: { visitor.visit(etl::get<31>(the_variant)); break; } default: break; } - }; + } }; #endif #endif diff --git a/include/etl/queue_lockable.h b/include/etl/queue_lockable.h index 75507a7a..7d467bf5 100644 --- a/include/etl/queue_lockable.h +++ b/include/etl/queue_lockable.h @@ -227,7 +227,7 @@ namespace etl //************************************************************************* bool full_implementation() const { - return (current_size == Max_Size);; + return (current_size == Max_Size); } //************************************************************************* @@ -781,7 +781,7 @@ namespace etl //************************************************************************* reference front_implementation() { - return p_buffer[this->read_index];; + return p_buffer[this->read_index]; } //************************************************************************* @@ -789,7 +789,7 @@ namespace etl //************************************************************************* const_reference front_implementation() const { - return p_buffer[this->read_index];; + return p_buffer[this->read_index]; } // Disable copy construction and assignment. diff --git a/include/etl/queue_spsc_locked.h b/include/etl/queue_spsc_locked.h index aa76cf09..ee53c5c6 100644 --- a/include/etl/queue_spsc_locked.h +++ b/include/etl/queue_spsc_locked.h @@ -406,7 +406,7 @@ namespace etl //************************************************************************* bool pop_from_unlocked(reference value) { - return pop_implementation(value);; + return pop_implementation(value); } //************************************************************************* diff --git a/include/etl/reference_counted_object.h b/include/etl/reference_counted_object.h index 198da27a..56b1278d 100644 --- a/include/etl/reference_counted_object.h +++ b/include/etl/reference_counted_object.h @@ -73,7 +73,7 @@ namespace etl { public: - virtual ~ireference_counter() {}; + virtual ~ireference_counter() {} virtual void set_reference_count(int32_t value) = 0; virtual void increment_reference_count() = 0; ETL_NODISCARD virtual int32_t decrement_reference_count() = 0; diff --git a/include/etl/rescale.h b/include/etl/rescale.h index 924542a5..394ed7c7 100644 --- a/include/etl/rescale.h +++ b/include/etl/rescale.h @@ -68,7 +68,7 @@ namespace etl //***************************************************************** TOutput operator ()(TInput value) const { - return TOutput(((value - input_min_value) * multiplier)) + output_min_value;; + return TOutput(((value - input_min_value) * multiplier)) + output_min_value; } private: diff --git a/include/etl/set.h b/include/etl/set.h index fa7d077a..dd4f208d 100644 --- a/include/etl/set.h +++ b/include/etl/set.h @@ -1355,7 +1355,7 @@ namespace etl key_compare key_comp() const { return compare; - }; + } //************************************************************************* /// How to compare two value elements. @@ -1363,7 +1363,7 @@ namespace etl value_compare value_comp() const { return compare; - }; + } //************************************************************************* /// Check if the set contains the key. diff --git a/include/etl/to_arithmetic.h b/include/etl/to_arithmetic.h index ffc8b9d5..a3fce142 100644 --- a/include/etl/to_arithmetic.h +++ b/include/etl/to_arithmetic.h @@ -844,7 +844,7 @@ namespace etl typename etl::enable_if::value, etl::to_arithmetic_result >::type to_arithmetic(const etl::ibasic_string& str, const etl::radix::value_type radix) { - return etl::to_arithmetic(etl::basic_string_view(str), radix);; + return etl::to_arithmetic(etl::basic_string_view(str), radix); } //*************************************************************************** @@ -856,7 +856,7 @@ namespace etl typename etl::enable_if::value, etl::to_arithmetic_result >::type to_arithmetic(const etl::ibasic_string& str) { - return etl::to_arithmetic(etl::basic_string_view(str), etl::radix::decimal);; + return etl::to_arithmetic(etl::basic_string_view(str), etl::radix::decimal); } //*************************************************************************** @@ -868,7 +868,7 @@ namespace etl typename etl::enable_if::value, etl::to_arithmetic_result >::type to_arithmetic(const etl::ibasic_string& str, const typename etl::private_basic_format_spec::base_spec& spec) { - return etl::to_arithmetic(etl::basic_string_view(str), spec);; + return etl::to_arithmetic(etl::basic_string_view(str), spec); } //*************************************************************************** diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 624f38d2..2afa0473 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -460,12 +460,14 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU") PRIVATE -fno-omit-frame-pointer -fno-common +# -pedantic-errors -Wall -Wextra -Werror -Wfloat-equal -Wshadow -Wnull-dereference + -Wextra-semi -g ) endif () @@ -475,12 +477,16 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") PRIVATE -fno-omit-frame-pointer -fno-common +# -pedantic-errors -Wall -Wextra -Werror -Wfloat-equal -Wshadow -Wnull-dereference + -Wextra-semi + -Wextra-semi-stmt + -Wc++11-extra-semi -g ) endif () diff --git a/test/etl_profile.h b/test/etl_profile.h index a7c680ff..d29a1093 100644 --- a/test/etl_profile.h +++ b/test/etl_profile.h @@ -42,7 +42,7 @@ SOFTWARE. #define ETL_IDEQUE_REPAIR_ENABLE #define ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE #define ETL_IN_UNIT_TEST -#define ETL_DEBUG_COUNT +//#define ETL_DEBUG_COUNT #define ETL_ARRAY_VIEW_IS_MUTABLE #define ETL_MESSAGE_TIMER_USE_ATOMIC_LOCK diff --git a/test/murmurhash3.cpp b/test/murmurhash3.cpp index dc1f0c13..d404a5cc 100644 --- a/test/murmurhash3.cpp +++ b/test/murmurhash3.cpp @@ -158,7 +158,7 @@ void MurmurHash3_x86_32(const void * key, int len, uint32_t seed, void * out) case 2: k1 ^= tail[1] << 8U; case 1: k1 ^= tail[0]; k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1; - }; + } //---------- // finalization @@ -251,7 +251,7 @@ void MurmurHash3_x86_128(const void * key, const int len, case 2: k1 ^= tail[1] << 8U; case 1: k1 ^= tail[0] << 0U; k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1; - }; + } //---------- // finalization @@ -337,7 +337,7 @@ void MurmurHash3_x64_128(const void * key, const int len, case 2: k1 ^= ((uint64_t)tail[1]) << 8U; case 1: k1 ^= ((uint64_t)tail[0]) << 0U; k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1; - }; + } //---------- // finalization diff --git a/test/syntax_check/CMakeLists.txt b/test/syntax_check/CMakeLists.txt index 31629a73..e6316fc7 100644 --- a/test/syntax_check/CMakeLists.txt +++ b/test/syntax_check/CMakeLists.txt @@ -35,10 +35,24 @@ set_target_properties(tests PROPERTIES CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS ON ) +if (CMAKE_CXX_COMPILER_ID MATCHES "GNU") target_compile_options(tests PRIVATE -fsyntax-only + -pedantic-errors + -Wextra-semi ) +endif () +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") +target_compile_options(tests + PRIVATE + -fsyntax-only + -pedantic-errors + -Wextra-semi + -Wextra-semi-stmt + -Wc++11-extra-semi + ) +endif () if (ETL_CXX_STANDARD MATCHES "98") message(STATUS "Compiling for C++98") diff --git a/test/test_algorithm.cpp b/test/test_algorithm.cpp index b7573bb0..f79ff95a 100644 --- a/test/test_algorithm.cpp +++ b/test/test_algorithm.cpp @@ -2504,5 +2504,5 @@ namespace CHECK_EQUAL(0, result5); CHECK_EQUAL(10, result6); } - }; + } } diff --git a/test/test_alignment.cpp b/test/test_alignment.cpp index 24ff4c28..ff461d25 100644 --- a/test/test_alignment.cpp +++ b/test/test_alignment.cpp @@ -284,5 +284,5 @@ namespace c.destroy(); CHECK_FALSE(c.has_value()); } - }; + } } diff --git a/test/test_array.cpp b/test/test_array.cpp index 857719f2..9edd0719 100644 --- a/test/test_array.cpp +++ b/test/test_array.cpp @@ -920,5 +920,5 @@ namespace #endif } #endif - }; + } } diff --git a/test/test_array_view.cpp b/test/test_array_view.cpp index 0202dcd1..0bb69eda 100644 --- a/test/test_array_view.cpp +++ b/test/test_array_view.cpp @@ -767,5 +767,5 @@ namespace bool isEqual = std::equal(filldata.begin(), filldata.end(), view.begin()); CHECK(isEqual); } - }; + } } diff --git a/test/test_array_wrapper.cpp b/test/test_array_wrapper.cpp index b93ff35d..cfcb4131 100644 --- a/test/test_array_wrapper.cpp +++ b/test/test_array_wrapper.cpp @@ -567,7 +567,7 @@ namespace CHECK_EQUAL(compare_hash, hash); } - }; + } } #if defined(ETL_COMPILER_CLANG) diff --git a/test/test_atomic.cpp b/test/test_atomic.cpp index 281b7650..a7442975 100644 --- a/test/test_atomic.cpp +++ b/test/test_atomic.cpp @@ -464,8 +464,8 @@ namespace //************************************************************************* TEST(test_atomic_operator_fetch_and) { - std::atomic compare(0xFFFFFFFFUL); - etl::atomic test(0xFFFFFFFFUL); + std::atomic compare(int(0xFFFFFFFFUL)); + etl::atomic test(int(0xFFFFFFFFUL)); CHECK_EQUAL(compare.fetch_and(0x55AA55AAUL), test.fetch_and(0x55AA55AAUL)); } @@ -766,5 +766,5 @@ namespace CHECK_EQUAL(0, atomic_value.load()); } #endif - }; + } } diff --git a/test/test_base64_RFC2152_decoder.cpp b/test/test_base64_RFC2152_decoder.cpp index 64cc11ca..66642b83 100644 --- a/test/test_base64_RFC2152_decoder.cpp +++ b/test/test_base64_RFC2152_decoder.cpp @@ -774,6 +774,6 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC2152_encoder.cpp b/test/test_base64_RFC2152_encoder.cpp index f463da39..947f0b57 100644 --- a/test/test_base64_RFC2152_encoder.cpp +++ b/test/test_base64_RFC2152_encoder.cpp @@ -744,6 +744,6 @@ namespace CHECK_TRUE(b64.overflow()); #endif } - }; + } } diff --git a/test/test_base64_RFC3501_decoder.cpp b/test/test_base64_RFC3501_decoder.cpp index 2e3c2faf..1c5e14e6 100644 --- a/test/test_base64_RFC3501_decoder.cpp +++ b/test/test_base64_RFC3501_decoder.cpp @@ -771,6 +771,6 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC3501_encoder.cpp b/test/test_base64_RFC3501_encoder.cpp index 0acc36a3..4c6f23ba 100644 --- a/test/test_base64_RFC3501_encoder.cpp +++ b/test/test_base64_RFC3501_encoder.cpp @@ -740,6 +740,6 @@ namespace CHECK_THROW((b64.encode(input_data.data(), 10)), etl::base64_overflow); CHECK_TRUE(b64.overflow()); } - }; + } } diff --git a/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp b/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp index c1c9280d..216cde1b 100644 --- a/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp +++ b/test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp @@ -786,6 +786,6 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC4648_URL_decoder_with_padding.cpp b/test/test_base64_RFC4648_URL_decoder_with_padding.cpp index ab75c182..990b6613 100644 --- a/test/test_base64_RFC4648_URL_decoder_with_padding.cpp +++ b/test/test_base64_RFC4648_URL_decoder_with_padding.cpp @@ -786,5 +786,5 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC4648_URL_encoder_with_no_padding.cpp b/test/test_base64_RFC4648_URL_encoder_with_no_padding.cpp index 56835228..798d2695 100644 --- a/test/test_base64_RFC4648_URL_encoder_with_no_padding.cpp +++ b/test/test_base64_RFC4648_URL_encoder_with_no_padding.cpp @@ -738,6 +738,6 @@ namespace CHECK_THROW((b64.encode(input_data.data(), 10)), etl::base64_overflow); CHECK_TRUE(b64.overflow()); } - }; + } } diff --git a/test/test_base64_RFC4648_URL_encoder_with_padding.cpp b/test/test_base64_RFC4648_URL_encoder_with_padding.cpp index 9c9f2e21..dc5fe71f 100644 --- a/test/test_base64_RFC4648_URL_encoder_with_padding.cpp +++ b/test/test_base64_RFC4648_URL_encoder_with_padding.cpp @@ -738,6 +738,6 @@ namespace CHECK_THROW((b64.encode(input_data.data(), 10)), etl::base64_overflow); CHECK_TRUE(b64.overflow()); } - }; + } } diff --git a/test/test_base64_RFC4648_decoder_with_no_padding.cpp b/test/test_base64_RFC4648_decoder_with_no_padding.cpp index 8fbde338..dddfd0eb 100644 --- a/test/test_base64_RFC4648_decoder_with_no_padding.cpp +++ b/test/test_base64_RFC4648_decoder_with_no_padding.cpp @@ -786,6 +786,6 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC4648_decoder_with_padding.cpp b/test/test_base64_RFC4648_decoder_with_padding.cpp index fef5112a..0b05fb9d 100644 --- a/test/test_base64_RFC4648_decoder_with_padding.cpp +++ b/test/test_base64_RFC4648_decoder_with_padding.cpp @@ -786,6 +786,6 @@ namespace CHECK_TRUE(b64.error()); #endif } - }; + } } diff --git a/test/test_base64_RFC4648_encoder_with_no_padding.cpp b/test/test_base64_RFC4648_encoder_with_no_padding.cpp index eefe003f..d09f3ac0 100644 --- a/test/test_base64_RFC4648_encoder_with_no_padding.cpp +++ b/test/test_base64_RFC4648_encoder_with_no_padding.cpp @@ -738,6 +738,6 @@ namespace CHECK_THROW((b64.encode(input_data.data(), 10)), etl::base64_overflow); CHECK_TRUE(b64.overflow()); } - }; + } } diff --git a/test/test_base64_RFC4648_encoder_with_padding.cpp b/test/test_base64_RFC4648_encoder_with_padding.cpp index 50b48b3b..74e9ae62 100644 --- a/test/test_base64_RFC4648_encoder_with_padding.cpp +++ b/test/test_base64_RFC4648_encoder_with_padding.cpp @@ -738,6 +738,6 @@ namespace CHECK_THROW((b64.encode(input_data.data(), 10)), etl::base64_overflow); CHECK_TRUE(b64.overflow()); } - }; + } } diff --git a/test/test_binary.cpp b/test/test_binary.cpp index 32d6343e..f8d54ada 100644 --- a/test/test_binary.cpp +++ b/test/test_binary.cpp @@ -3052,7 +3052,7 @@ namespace CHECK_ARRAY_EQUAL(expected.data(), output.data(), expected.size()); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bip_buffer_spsc_atomic.cpp b/test/test_bip_buffer_spsc_atomic.cpp index c850ec92..9711685d 100644 --- a/test/test_bip_buffer_spsc_atomic.cpp +++ b/test/test_bip_buffer_spsc_atomic.cpp @@ -392,7 +392,7 @@ namespace } } #endif - }; + } } #endif // ETL_HAS_ATOMIC diff --git a/test/test_bit.cpp b/test/test_bit.cpp index 176345c8..0443de68 100644 --- a/test/test_bit.cpp +++ b/test/test_bit.cpp @@ -1563,7 +1563,7 @@ namespace CHECK_EQUAL(test_bit_width(uint64_t(0xAU)), sizeof(temp)); } #endif - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bit_stream.cpp b/test/test_bit_stream.cpp index 666e5911..6d232995 100644 --- a/test/test_bit_stream.cpp +++ b/test/test_bit_stream.cpp @@ -1072,7 +1072,7 @@ namespace CHECK(bit_stream.get(rd)); CHECK_CLOSE(f, rd, 0.1f); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bit_stream_reader_big_endian.cpp b/test/test_bit_stream_reader_big_endian.cpp index 9c099085..f7aadf2e 100644 --- a/test/test_bit_stream_reader_big_endian.cpp +++ b/test/test_bit_stream_reader_big_endian.cpp @@ -1504,7 +1504,7 @@ namespace CHECK_EQUAL(object2.i, result2.i); CHECK_EQUAL(object2.c, result2.c); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bit_stream_reader_little_endian.cpp b/test/test_bit_stream_reader_little_endian.cpp index fcf91b22..c2e86d05 100644 --- a/test/test_bit_stream_reader_little_endian.cpp +++ b/test/test_bit_stream_reader_little_endian.cpp @@ -1192,7 +1192,7 @@ namespace CHECK_EQUAL(object2.i, result2.i); CHECK_EQUAL(object2.c, result2.c); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bit_stream_writer_big_endian.cpp b/test/test_bit_stream_writer_big_endian.cpp index 429d1754..ddcf25b2 100644 --- a/test/test_bit_stream_writer_big_endian.cpp +++ b/test/test_bit_stream_writer_big_endian.cpp @@ -814,7 +814,7 @@ namespace CHECK_EQUAL(bit_stream.empty(), false); CHECK_EQUAL(bit_stream.full(), true); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bit_stream_writer_little_endian.cpp b/test/test_bit_stream_writer_little_endian.cpp index 56e47287..7094bfe6 100644 --- a/test/test_bit_stream_writer_little_endian.cpp +++ b/test/test_bit_stream_writer_little_endian.cpp @@ -902,7 +902,7 @@ namespace CHECK_EQUAL(bit_stream.empty(), false); CHECK_EQUAL(bit_stream.full(), true); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_bitset_legacy.cpp b/test/test_bitset_legacy.cpp index 7723b172..45fae83f 100644 --- a/test/test_bitset_legacy.cpp +++ b/test/test_bitset_legacy.cpp @@ -1532,5 +1532,5 @@ namespace etl::bitset<0> shiftbits = bits << 1; // No exception. } - }; + } } diff --git a/test/test_bitset_new_comparisons.cpp b/test/test_bitset_new_comparisons.cpp index 4436982f..b88684d6 100644 --- a/test/test_bitset_new_comparisons.cpp +++ b/test/test_bitset_new_comparisons.cpp @@ -235,5 +235,5 @@ namespace CHECK(data2 != data3); // bitset (M) != bitset_ext (S) CHECK(data3 != data2); // bitset_ext (S) != bitset (M) } - }; + } } diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp index 30619fcf..6730948c 100644 --- a/test/test_bitset_new_default_element_type.cpp +++ b/test/test_bitset_new_default_element_type.cpp @@ -2709,5 +2709,5 @@ namespace CHECK_EQUAL(32, ETL_OR_STD17::size(b)); } - }; + } } diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index f06d4d42..c4cce00e 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -2823,5 +2823,5 @@ namespace CHECK_EQUAL(32, ETL_OR_STD17::size(b)); } - }; + } } diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp index 3cc9fc25..75b81eb0 100644 --- a/test/test_bitset_new_ext_default_element_type.cpp +++ b/test/test_bitset_new_ext_default_element_type.cpp @@ -2459,5 +2459,5 @@ namespace CHECK_EQUAL(32, ETL_OR_STD17::size(b)); } - }; + } } diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp index 75c18a5f..6542cbf2 100644 --- a/test/test_bitset_new_ext_explicit_single_element_type.cpp +++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp @@ -2627,5 +2627,5 @@ namespace CHECK_EQUAL(32, ETL_OR_STD17::size(b)); } - }; + } } diff --git a/test/test_bloom_filter.cpp b/test/test_bloom_filter.cpp index 12768336..804e5fa6 100644 --- a/test/test_bloom_filter.cpp +++ b/test/test_bloom_filter.cpp @@ -260,6 +260,6 @@ namespace CHECK(!any_exist); } - }; + } } diff --git a/test/test_bresenham_line.cpp b/test/test_bresenham_line.cpp index e350e894..a0ccd53b 100644 --- a/test/test_bresenham_line.cpp +++ b/test/test_bresenham_line.cpp @@ -436,5 +436,5 @@ namespace CHECK(bl1 != bl4); CHECK(!(bl1 == bl4)); } - }; + } } diff --git a/test/test_bsd_checksum.cpp b/test/test_bsd_checksum.cpp index 2dff6c74..8c37ca35 100644 --- a/test/test_bsd_checksum.cpp +++ b/test/test_bsd_checksum.cpp @@ -173,6 +173,6 @@ namespace CHECK_EQUAL(hash1, hash2); CHECK_EQUAL(hash1, hash3); } - }; + } } diff --git a/test/test_buffer_descriptors.cpp b/test/test_buffer_descriptors.cpp index e66729f2..030f718a 100644 --- a/test/test_buffer_descriptors.cpp +++ b/test/test_buffer_descriptors.cpp @@ -403,5 +403,5 @@ namespace t2.join(); } #endif - }; + } } diff --git a/test/test_byte_stream.cpp b/test/test_byte_stream.cpp index 4d63068d..f6c461af 100644 --- a/test/test_byte_stream.cpp +++ b/test/test_byte_stream.cpp @@ -1348,7 +1348,7 @@ namespace CHECK_FALSE(result.has_value()); CHECK_TRUE(r.empty()); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_callback_service.cpp b/test/test_callback_service.cpp index c2f89db2..420ec1c0 100644 --- a/test/test_callback_service.cpp +++ b/test/test_callback_service.cpp @@ -329,5 +329,5 @@ namespace CHECK(!member2_called); CHECK(unhandled_called); } - }; + } } diff --git a/test/test_callback_timer.cpp b/test/test_callback_timer.cpp index 62b2a059..471e25d4 100644 --- a/test/test_callback_timer.cpp +++ b/test/test_callback_timer.cpp @@ -945,5 +945,5 @@ namespace //CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), min(compare2.size(), free_tick_list1.size())); } #endif - }; + } } diff --git a/test/test_callback_timer_atomic.cpp b/test/test_callback_timer_atomic.cpp index 01b09e89..34f4ce81 100644 --- a/test/test_callback_timer_atomic.cpp +++ b/test/test_callback_timer_atomic.cpp @@ -951,7 +951,7 @@ namespace //CHECK_ARRAY_EQUAL(compare2.data(), free_tick_list1.data(), min(compare2.size(), free_tick_list1.size())); } #endif - }; + } } #endif diff --git a/test/test_callback_timer_deferred_locked.cpp b/test/test_callback_timer_deferred_locked.cpp index 46aaafe5..3fb551fe 100644 --- a/test/test_callback_timer_deferred_locked.cpp +++ b/test/test_callback_timer_deferred_locked.cpp @@ -1264,5 +1264,5 @@ namespace CHECK_EQUAL(0U, threadLock.lock_count); } #endif - }; + } } diff --git a/test/test_callback_timer_interrupt.cpp b/test/test_callback_timer_interrupt.cpp index ae373c6e..41ed325c 100644 --- a/test/test_callback_timer_interrupt.cpp +++ b/test/test_callback_timer_interrupt.cpp @@ -996,5 +996,5 @@ namespace // Check the CHECK_EQUAL(0U, ScopedGuard::guard_count); } - }; + } } diff --git a/test/test_callback_timer_locked.cpp b/test/test_callback_timer_locked.cpp index ddeda3a4..76240d0c 100644 --- a/test/test_callback_timer_locked.cpp +++ b/test/test_callback_timer_locked.cpp @@ -1146,5 +1146,5 @@ namespace CHECK_EQUAL(0U, threadLock.lock_count); } #endif - }; + } } diff --git a/test/test_char_traits.cpp b/test/test_char_traits.cpp index 75b6dad3..5b43ed94 100644 --- a/test/test_char_traits.cpp +++ b/test/test_char_traits.cpp @@ -750,7 +750,7 @@ namespace CHECK(int_type(char_traits::eof()) != char_traits::not_eof(char_traits::eof())); CHECK(int_type(char_traits::eof() + 1) == char_traits::not_eof(char_traits::eof() + 1)); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_checksum.cpp b/test/test_checksum.cpp index 207e927a..99819254 100644 --- a/test/test_checksum.cpp +++ b/test/test_checksum.cpp @@ -181,6 +181,6 @@ namespace uint32_t hash3 = etl::checksum(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(hash1), int(hash3)); } - }; + } } diff --git a/test/test_chrono_clocks.cpp b/test/test_chrono_clocks.cpp index 31ceadc7..78deb309 100644 --- a/test/test_chrono_clocks.cpp +++ b/test/test_chrono_clocks.cpp @@ -171,5 +171,5 @@ namespace CHECK_EQUAL(sys_clock_count, scaled_steady_lock_count); } - }; + } } diff --git a/test/test_chrono_day.cpp b/test/test_chrono_day.cpp index d7066c61..af9dec6c 100644 --- a/test/test_chrono_day.cpp +++ b/test/test_chrono_day.cpp @@ -323,5 +323,5 @@ namespace CHECK_EQUAL(256U, hashes.size()); } #endif - }; + } } diff --git a/test/test_chrono_duration.cpp b/test/test_chrono_duration.cpp index 8da3d36d..935d2c71 100644 --- a/test/test_chrono_duration.cpp +++ b/test/test_chrono_duration.cpp @@ -1138,5 +1138,5 @@ namespace #endif } #endif - }; + } } diff --git a/test/test_chrono_hh_mm_ss.cpp b/test/test_chrono_hh_mm_ss.cpp index 887bb42f..b051a988 100644 --- a/test/test_chrono_hh_mm_ss.cpp +++ b/test/test_chrono_hh_mm_ss.cpp @@ -285,5 +285,5 @@ namespace CHECK_EQUAL(0, time.fractional_width); CHECK_TRUE((std::is_same::precision>::value)); } - }; + } } diff --git a/test/test_chrono_literals.cpp b/test/test_chrono_literals.cpp index 00fde480..d9d30e9a 100644 --- a/test/test_chrono_literals.cpp +++ b/test/test_chrono_literals.cpp @@ -84,5 +84,5 @@ namespace CHECK_TRUE(etl::chrono::microseconds(1000) == 1000_microseconds); CHECK_TRUE(etl::chrono::nanoseconds(10000) == 10000_nanoseconds); } - }; + } } diff --git a/test/test_chrono_month.cpp b/test/test_chrono_month.cpp index 47c633fd..765d018f 100644 --- a/test/test_chrono_month.cpp +++ b/test/test_chrono_month.cpp @@ -352,5 +352,5 @@ namespace CHECK_EQUAL(11U, static_cast(Chrono::November)); CHECK_EQUAL(12U, static_cast(Chrono::December)); } - }; + } } diff --git a/test/test_chrono_month_day.cpp b/test/test_chrono_month_day.cpp index edd32e0e..c79eceea 100644 --- a/test/test_chrono_month_day.cpp +++ b/test/test_chrono_month_day.cpp @@ -210,6 +210,5 @@ namespace CHECK_EQUAL(Chrono::December, md_max.month()); CHECK_EQUAL(Chrono::day{31}, md_max.day()); } - - }; + } } diff --git a/test/test_chrono_month_day_last.cpp b/test/test_chrono_month_day_last.cpp index ec9b6ae4..4685215e 100644 --- a/test/test_chrono_month_day_last.cpp +++ b/test/test_chrono_month_day_last.cpp @@ -126,5 +126,5 @@ namespace (void)std::unique(hashes.begin(), hashes.end()); } #endif - }; + } } diff --git a/test/test_chrono_month_weekday.cpp b/test/test_chrono_month_weekday.cpp index 29b532ab..5853bca7 100644 --- a/test/test_chrono_month_weekday.cpp +++ b/test/test_chrono_month_weekday.cpp @@ -120,5 +120,5 @@ namespace CHECK_EQUAL(256U, hashes.size()); } #endif - }; + } } diff --git a/test/test_chrono_month_weekday_last.cpp b/test/test_chrono_month_weekday_last.cpp index a79fe0e1..87d448c5 100644 --- a/test/test_chrono_month_weekday_last.cpp +++ b/test/test_chrono_month_weekday_last.cpp @@ -121,5 +121,5 @@ namespace CHECK_EQUAL(256U, hashes.size()); } #endif - }; + } } diff --git a/test/test_chrono_operators.cpp b/test/test_chrono_operators.cpp index 74a69f90..ecccba63 100644 --- a/test/test_chrono_operators.cpp +++ b/test/test_chrono_operators.cpp @@ -281,5 +281,5 @@ namespace CHECK_EQUAL(etl::chrono::May, ymdl5.month()); CHECK_EQUAL(etl::chrono::weekday_last(etl::chrono::Friday).weekday().c_encoding(), ymdl5.weekday().c_encoding()); } - }; + } } \ No newline at end of file diff --git a/test/test_chrono_time_point.cpp b/test/test_chrono_time_point.cpp index abf1cefc..9eb13ddb 100644 --- a/test/test_chrono_time_point.cpp +++ b/test/test_chrono_time_point.cpp @@ -358,5 +358,5 @@ namespace CHECK_EQUAL(expected, actual); } - }; + } } diff --git a/test/test_chrono_weekday.cpp b/test/test_chrono_weekday.cpp index 6f4cc5ee..7aa52251 100644 --- a/test/test_chrono_weekday.cpp +++ b/test/test_chrono_weekday.cpp @@ -383,5 +383,5 @@ namespace CHECK_EQUAL(256U, hashes.size()); } #endif - }; + } } diff --git a/test/test_chrono_weekday_indexed.cpp b/test/test_chrono_weekday_indexed.cpp index abaa6aad..92b9221b 100644 --- a/test/test_chrono_weekday_indexed.cpp +++ b/test/test_chrono_weekday_indexed.cpp @@ -159,5 +159,5 @@ namespace (void)std::unique(hashes.begin(), hashes.end()); } #endif - }; + } } diff --git a/test/test_chrono_weekday_last.cpp b/test/test_chrono_weekday_last.cpp index 4db7e658..9b949160 100644 --- a/test/test_chrono_weekday_last.cpp +++ b/test/test_chrono_weekday_last.cpp @@ -131,5 +131,5 @@ namespace (void)std::unique(hashes.begin(), hashes.end()); } #endif - }; + } } diff --git a/test/test_chrono_year.cpp b/test/test_chrono_year.cpp index a86d5a4c..e7ec7904 100644 --- a/test/test_chrono_year.cpp +++ b/test/test_chrono_year.cpp @@ -313,5 +313,5 @@ namespace CHECK_EQUAL(65535U, hashes.size()); } #endif - }; + } } diff --git a/test/test_chrono_year_month.cpp b/test/test_chrono_year_month.cpp index a0e8ab7f..e016e8c4 100644 --- a/test/test_chrono_year_month.cpp +++ b/test/test_chrono_year_month.cpp @@ -144,5 +144,5 @@ namespace CHECK_TRUE(ym1 != ym2); // Different year CHECK_TRUE(ym1 != ym3); // Different month } - }; + } } diff --git a/test/test_chrono_year_month_day.cpp b/test/test_chrono_year_month_day.cpp index c7e9cabd..a5710e73 100644 --- a/test/test_chrono_year_month_day.cpp +++ b/test/test_chrono_year_month_day.cpp @@ -225,5 +225,5 @@ namespace CHECK_TRUE(ym1 != ym3); // Different month CHECK_TRUE(ym1 != ym4); // Different day } - }; + } } diff --git a/test/test_chrono_year_month_day_last.cpp b/test/test_chrono_year_month_day_last.cpp index 4e9145b0..e2ada34c 100644 --- a/test/test_chrono_year_month_day_last.cpp +++ b/test/test_chrono_year_month_day_last.cpp @@ -195,5 +195,5 @@ namespace CHECK_EQUAL(11016, sd.time_since_epoch().count()); } - }; + } } diff --git a/test/test_chrono_year_month_weekday.cpp b/test/test_chrono_year_month_weekday.cpp index 9e3f38bc..fdb9c4d2 100644 --- a/test/test_chrono_year_month_weekday.cpp +++ b/test/test_chrono_year_month_weekday.cpp @@ -150,5 +150,5 @@ namespace CHECK_TRUE(ym1 != ym3); // Different month CHECK_TRUE(ym1 != ym4); // Different day } - }; + } } diff --git a/test/test_chrono_year_month_weekday_last.cpp b/test/test_chrono_year_month_weekday_last.cpp index 1084398b..409c2d93 100644 --- a/test/test_chrono_year_month_weekday_last.cpp +++ b/test/test_chrono_year_month_weekday_last.cpp @@ -103,5 +103,5 @@ namespace CHECK_TRUE(ym1 != ym3); // Different month CHECK_TRUE(ym1 != ym4); // Different day } - }; + } } diff --git a/test/test_circular_buffer.cpp b/test/test_circular_buffer.cpp index d4e6314c..b7cc15d0 100644 --- a/test/test_circular_buffer.cpp +++ b/test/test_circular_buffer.cpp @@ -997,7 +997,7 @@ namespace using CB = etl::circular_buffer; std::vector input = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - CB data(input.begin(), input.end());; + CB data(input.begin(), input.end()); char buffer[sizeof(CB)]; @@ -1034,7 +1034,7 @@ namespace using ICB = etl::icircular_buffer; std::vector input = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; - CB data(input.begin(), input.end());; + CB data(input.begin(), input.end()); char buffer[sizeof(CB)]; @@ -1063,6 +1063,5 @@ namespace CHECK(!is_equal); } - - }; + } } diff --git a/test/test_circular_buffer_external_buffer.cpp b/test/test_circular_buffer_external_buffer.cpp index 40d1933f..a86da8c0 100644 --- a/test/test_circular_buffer_external_buffer.cpp +++ b/test/test_circular_buffer_external_buffer.cpp @@ -1096,5 +1096,5 @@ namespace CHECK(data1 != data2); } - }; + } } diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp index 191b4ad5..167af271 100644 --- a/test/test_circular_iterator.cpp +++ b/test/test_circular_iterator.cpp @@ -699,5 +699,5 @@ namespace CHECK(ci1 != ci3); CHECK(ci3 != ci1); } - }; + } } diff --git a/test/test_closure.cpp b/test/test_closure.cpp index 2a9f41a0..dc48fea3 100644 --- a/test/test_closure.cpp +++ b/test/test_closure.cpp @@ -187,5 +187,5 @@ namespace //c.bind(1, 2, 3); // Argument count mismatch //c.bind(1, std::string()); // Argument is not convertible } - }; + } } diff --git a/test/test_closure_constexpr.cpp b/test/test_closure_constexpr.cpp index 4467a882..fb8b2e2d 100644 --- a/test/test_closure_constexpr.cpp +++ b/test/test_closure_constexpr.cpp @@ -158,7 +158,7 @@ namespace static constexpr int result = c5(); CHECK_EQUAL(23, result); } - }; + } } #endif diff --git a/test/test_compare.cpp b/test/test_compare.cpp index f0de4b26..e9cefbe3 100644 --- a/test/test_compare.cpp +++ b/test/test_compare.cpp @@ -191,5 +191,5 @@ namespace CHECK_EQUAL(CompareInt::Greater, cmp_test_greater); CHECK_EQUAL(CompareInt::Equal, cmp_test_equal); } - }; + } } diff --git a/test/test_const_map.cpp b/test/test_const_map.cpp index 65efe5b4..2774cd9d 100644 --- a/test/test_const_map.cpp +++ b/test/test_const_map.cpp @@ -1152,7 +1152,7 @@ namespace static const bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static const bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1197,7 +1197,7 @@ namespace static const bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static const bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static const bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static const bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1574,5 +1574,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_map_constexpr.cpp b/test/test_const_map_constexpr.cpp index eca2b48e..b52ed59f 100644 --- a/test/test_const_map_constexpr.cpp +++ b/test/test_const_map_constexpr.cpp @@ -1154,7 +1154,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static constexpr bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1199,7 +1199,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static constexpr bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1576,7 +1576,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_map_ext.cpp b/test/test_const_map_ext.cpp index fc3ed33e..5867ccaa 100644 --- a/test/test_const_map_ext.cpp +++ b/test/test_const_map_ext.cpp @@ -1236,7 +1236,7 @@ namespace static const bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static const bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1281,7 +1281,7 @@ namespace static const bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static const bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static const bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static const bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1709,5 +1709,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_map_ext_constexpr.cpp b/test/test_const_map_ext_constexpr.cpp index c1735fff..db0ad13f 100644 --- a/test/test_const_map_ext_constexpr.cpp +++ b/test/test_const_map_ext_constexpr.cpp @@ -1238,7 +1238,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static constexpr bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1283,7 +1283,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static constexpr bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1711,7 +1711,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_multimap.cpp b/test/test_const_multimap.cpp index 46457b41..bb45eee2 100644 --- a/test/test_const_multimap.cpp +++ b/test/test_const_multimap.cpp @@ -900,7 +900,7 @@ namespace static const bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static const bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -945,7 +945,7 @@ namespace static const bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static const bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static const bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static const bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1321,5 +1321,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_multimap_constexpr.cpp b/test/test_const_multimap_constexpr.cpp index a881c491..6c87ba94 100644 --- a/test/test_const_multimap_constexpr.cpp +++ b/test/test_const_multimap_constexpr.cpp @@ -833,7 +833,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static constexpr bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -878,7 +878,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static constexpr bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1254,7 +1254,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_multimap_ext.cpp b/test/test_const_multimap_ext.cpp index b68ad450..32bc629a 100644 --- a/test/test_const_multimap_ext.cpp +++ b/test/test_const_multimap_ext.cpp @@ -1042,7 +1042,7 @@ namespace static const bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static const bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static const bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1087,7 +1087,7 @@ namespace static const bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static const bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static const bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static const bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1516,5 +1516,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_multimap_ext_constexpr.cpp b/test/test_const_multimap_ext_constexpr.cpp index 9425e42b..a373ce65 100644 --- a/test/test_const_multimap_ext_constexpr.cpp +++ b/test/test_const_multimap_ext_constexpr.cpp @@ -1035,7 +1035,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'B' }, 0 }); static constexpr bool compareAB2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 });; + static constexpr bool compareAB3 = compare(Key{ 'A' }, value_type{ Key{ 'B' }, 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1080,7 +1080,7 @@ namespace static constexpr bool compareAB1 = compare(value_type{ 'A', 0 }, value_type{ 'B', 0 }); static constexpr bool compareAB2 = compare(value_type{ 'A', 0 }, 'B'); - static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 });; + static constexpr bool compareAB3 = compare('A', value_type{ 'B', 0 }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1509,7 +1509,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_multiset.cpp b/test/test_const_multiset.cpp index b5102738..f7fc71a3 100644 --- a/test/test_const_multiset.cpp +++ b/test/test_const_multiset.cpp @@ -903,7 +903,7 @@ namespace static const bool compareAB1 = compare(Key('A'), Key('B')); static const bool compareAB2 = compare(Key('A'), Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, Key('B'));; + static const bool compareAB3 = compare(Key{ 'A' }, Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -948,7 +948,7 @@ namespace static const bool compareAB1 = compare(Key('A'), Key('B')); static const bool compareAB2 = compare(Key('A'), 'B'); - static const bool compareAB3 = compare('A', Key('B'));; + static const bool compareAB3 = compare('A', Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1324,5 +1324,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_multiset_constexpr.cpp b/test/test_const_multiset_constexpr.cpp index 95dc2db7..ae4c41f5 100644 --- a/test/test_const_multiset_constexpr.cpp +++ b/test/test_const_multiset_constexpr.cpp @@ -905,7 +905,7 @@ namespace static constexpr bool compareAB1 = compare(Key('A'), Key('B')); static constexpr bool compareAB2 = compare(Key('A'), Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, Key('B'));; + static constexpr bool compareAB3 = compare(Key{ 'A' }, Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -950,7 +950,7 @@ namespace static constexpr bool compareAB1 = compare(Key('A'), Key('B')); static constexpr bool compareAB2 = compare(Key('A'), 'B'); - static constexpr bool compareAB3 = compare('A', Key('B'));; + static constexpr bool compareAB3 = compare('A', Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1326,7 +1326,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_multiset_ext.cpp b/test/test_const_multiset_ext.cpp index 6574eff2..76a2592e 100644 --- a/test/test_const_multiset_ext.cpp +++ b/test/test_const_multiset_ext.cpp @@ -948,7 +948,7 @@ namespace static const bool compareAB1 = compare(Key('A'), Key('B')); static const bool compareAB2 = compare(Key('A'), Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, Key('B'));; + static const bool compareAB3 = compare(Key{ 'A' }, Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -993,7 +993,7 @@ namespace static const bool compareAB1 = compare(Key('A'), Key('B')); static const bool compareAB2 = compare(Key('A'), 'B'); - static const bool compareAB3 = compare('A', Key('B'));; + static const bool compareAB3 = compare('A', Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1421,5 +1421,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_multiset_ext_constexpr.cpp b/test/test_const_multiset_ext_constexpr.cpp index 2cff9b54..42043e31 100644 --- a/test/test_const_multiset_ext_constexpr.cpp +++ b/test/test_const_multiset_ext_constexpr.cpp @@ -950,7 +950,7 @@ namespace static constexpr bool compareAB1 = compare(Key('A'), Key('B')); static constexpr bool compareAB2 = compare(Key('A'), Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, Key('B'));; + static constexpr bool compareAB3 = compare(Key{ 'A' }, Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -995,7 +995,7 @@ namespace static constexpr bool compareAB1 = compare(Key('A'), Key('B')); static constexpr bool compareAB2 = compare(Key('A'), 'B'); - static constexpr bool compareAB3 = compare('A', Key('B'));; + static constexpr bool compareAB3 = compare('A', Key('B')); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1423,7 +1423,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_set.cpp b/test/test_const_set.cpp index 06ed6b44..15ad54dd 100644 --- a/test/test_const_set.cpp +++ b/test/test_const_set.cpp @@ -1012,7 +1012,7 @@ namespace static const bool compareAB1 = compare( Key{ 'A' }, Key{ 'B' }); static const bool compareAB2 = compare( Key{ 'A' }, Key{ 'B' }); - static const bool compareAB3 = compare( Key{ 'A' }, Key{ 'B' });; + static const bool compareAB3 = compare( Key{ 'A' }, Key{ 'B' }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1433,5 +1433,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_set_constexpr.cpp b/test/test_const_set_constexpr.cpp index c126bddf..8f4286e0 100644 --- a/test/test_const_set_constexpr.cpp +++ b/test/test_const_set_constexpr.cpp @@ -33,10 +33,10 @@ SOFTWARE. #include #include -#if ETL_USING_CPP14 - #include "etl/const_set.h" +#if ETL_USING_CPP14 + namespace { static constexpr size_t Max_Size = 10UL; @@ -85,11 +85,13 @@ namespace return (lhs.k == rhs.k); } +#if ETL_NOT_USING_CPP20 // Equality operator for Key != Key constexpr bool operator !=(const Key& lhs, const Key& rhs) noexcept { return !(lhs.k == rhs.k); } +#endif #define TEST_GREATER_THAN #ifdef TEST_GREATER_THAN @@ -1012,7 +1014,7 @@ namespace static constexpr bool compareAB1 = compare( Key{ 'A' }, Key{ 'B' }); static constexpr bool compareAB2 = compare( Key{ 'A' }, Key{ 'B' }); - static constexpr bool compareAB3 = compare( Key{ 'A' }, Key{ 'B' });; + static constexpr bool compareAB3 = compare( Key{ 'A' }, Key{ 'B' }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1433,7 +1435,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_const_set_ext.cpp b/test/test_const_set_ext.cpp index d9d194c0..c0176968 100644 --- a/test/test_const_set_ext.cpp +++ b/test/test_const_set_ext.cpp @@ -1095,7 +1095,7 @@ namespace static const bool compareAB1 = compare( Key{ 'A' }, Key{ 'B' }); static const bool compareAB2 = compare( Key{ 'A' }, Key{ 'B' }); - static const bool compareAB3 = compare(Key{ 'A' }, Key{ 'B' });; + static const bool compareAB3 = compare(Key{ 'A' }, Key{ 'B' }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1140,7 +1140,7 @@ namespace static const bool compareAB1 = compare( 'A', 'B'); static const bool compareAB2 = compare( 'A', 'B'); - static const bool compareAB3 = compare('A', 'B');; + static const bool compareAB3 = compare('A', 'B'); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1568,5 +1568,5 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } diff --git a/test/test_const_set_ext_constexpr.cpp b/test/test_const_set_ext_constexpr.cpp index ab5bd491..23161cb8 100644 --- a/test/test_const_set_ext_constexpr.cpp +++ b/test/test_const_set_ext_constexpr.cpp @@ -1097,7 +1097,7 @@ namespace static constexpr bool compareAB1 = compare( Key{ 'A' }, Key{ 'B' }); static constexpr bool compareAB2 = compare( Key{ 'A' }, Key{ 'B' }); - static constexpr bool compareAB3 = compare(Key{ 'A' }, Key{ 'B' });; + static constexpr bool compareAB3 = compare(Key{ 'A' }, Key{ 'B' }); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1142,7 +1142,7 @@ namespace static constexpr bool compareAB1 = compare( 'A', 'B'); static constexpr bool compareAB2 = compare( 'A', 'B'); - static constexpr bool compareAB3 = compare('A', 'B');; + static constexpr bool compareAB3 = compare('A', 'B'); #ifdef TEST_GREATER_THAN CHECK_FALSE(compareAA1); @@ -1570,7 +1570,7 @@ namespace CHECK_TRUE(greater_than_equal11); #endif } - }; + } } #endif diff --git a/test/test_constant.cpp b/test/test_constant.cpp index e6bdd0c7..06130431 100644 --- a/test/test_constant.cpp +++ b/test/test_constant.cpp @@ -61,5 +61,5 @@ namespace CHECK_EQUAL((int64_t)etl::integral_limits::max, C3::value); CHECK((etl::is_same::value)); } - }; + } } diff --git a/test/test_container.cpp b/test/test_container.cpp index e2fbb811..ece1afba 100644 --- a/test/test_container.cpp +++ b/test/test_container.cpp @@ -145,7 +145,7 @@ namespace size_t compiletime_size = sizeof(etl::array_size(data)); CHECK_EQUAL(SIZE, compiletime_size); } - }; + } } #endif diff --git a/test/test_correlation.cpp b/test/test_correlation.cpp index 2bd689f1..8f86334a 100644 --- a/test/test_correlation.cpp +++ b/test/test_correlation.cpp @@ -280,5 +280,5 @@ namespace covariance_result = correlation3.get_covariance(); CHECK_CLOSE(9.17, covariance_result, 0.1); } - }; + } } diff --git a/test/test_covariance.cpp b/test/test_covariance.cpp index 705f1e12..fa86a393 100644 --- a/test/test_covariance.cpp +++ b/test/test_covariance.cpp @@ -238,5 +238,5 @@ namespace covariance_result = covariance3.get_covariance(); CHECK_CLOSE(9.17, covariance_result, 0.1); } - }; + } } diff --git a/test/test_crc1.cpp b/test/test_crc1.cpp index 4bbabefa..fb843c1a 100644 --- a/test/test_crc1.cpp +++ b/test/test_crc1.cpp @@ -146,6 +146,6 @@ namespace CHECK_EQUAL(etl::crc1::odd_parity, etl::crc1(data_odd.begin(), data_odd.end())); CHECK_EQUAL(etl::crc1::even_parity, etl::crc1(data_even.begin(), data_even.end())); } - }; + } } diff --git a/test/test_crc16.cpp b/test/test_crc16.cpp index de947c94..6bc37840 100644 --- a/test/test_crc16.cpp +++ b/test/test_crc16.cpp @@ -305,6 +305,6 @@ namespace uint16_t crc3 = etl::crc16_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_a.cpp b/test/test_crc16_a.cpp index 2dd49ee5..ebad7bf5 100644 --- a/test/test_crc16_a.cpp +++ b/test/test_crc16_a.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_a_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_arc.cpp b/test/test_crc16_arc.cpp index 8e7376bf..2762fe79 100644 --- a/test/test_crc16_arc.cpp +++ b/test/test_crc16_arc.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_arc_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_aug_ccitt.cpp b/test/test_crc16_aug_ccitt.cpp index 54ce1d2b..9b33bb03 100644 --- a/test/test_crc16_aug_ccitt.cpp +++ b/test/test_crc16_aug_ccitt.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_aug_ccitt_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_buypass.cpp b/test/test_crc16_buypass.cpp index 14b2b45d..87ffd57a 100644 --- a/test/test_crc16_buypass.cpp +++ b/test/test_crc16_buypass.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_buypass_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_ccitt.cpp b/test/test_crc16_ccitt.cpp index 3492252e..2fe6fb61 100644 --- a/test/test_crc16_ccitt.cpp +++ b/test/test_crc16_ccitt.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_ccitt_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_cdma2000.cpp b/test/test_crc16_cdma2000.cpp index b80b1891..40e420ee 100644 --- a/test/test_crc16_cdma2000.cpp +++ b/test/test_crc16_cdma2000.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_cdma2000_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_dds110.cpp b/test/test_crc16_dds110.cpp index 20e1869f..34dcfa84 100644 --- a/test/test_crc16_dds110.cpp +++ b/test/test_crc16_dds110.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_dds110_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_dectr.cpp b/test/test_crc16_dectr.cpp index e713b725..5274b37a 100644 --- a/test/test_crc16_dectr.cpp +++ b/test/test_crc16_dectr.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_dect_r_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_dectx.cpp b/test/test_crc16_dectx.cpp index f3e77a15..4ce202be 100644 --- a/test/test_crc16_dectx.cpp +++ b/test/test_crc16_dectx.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_dect_x_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_dnp.cpp b/test/test_crc16_dnp.cpp index 5402dd9d..2bf15b10 100644 --- a/test/test_crc16_dnp.cpp +++ b/test/test_crc16_dnp.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_dnp_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_en13757.cpp b/test/test_crc16_en13757.cpp index a70b3425..067fb58c 100644 --- a/test/test_crc16_en13757.cpp +++ b/test/test_crc16_en13757.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_en13757_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_genibus.cpp b/test/test_crc16_genibus.cpp index 1ab9bbf1..46191e00 100644 --- a/test/test_crc16_genibus.cpp +++ b/test/test_crc16_genibus.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_genibus_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_kermit.cpp b/test/test_crc16_kermit.cpp index 32fc673e..a759056d 100644 --- a/test/test_crc16_kermit.cpp +++ b/test/test_crc16_kermit.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_kermit_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_m17.cpp b/test/test_crc16_m17.cpp index 5a6fda2d..b1ee95c2 100644 --- a/test/test_crc16_m17.cpp +++ b/test/test_crc16_m17.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_m17_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_maxim.cpp b/test/test_crc16_maxim.cpp index 38b3058b..eab8ff09 100644 --- a/test/test_crc16_maxim.cpp +++ b/test/test_crc16_maxim.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_maxim_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_mcrf4xx.cpp b/test/test_crc16_mcrf4xx.cpp index b7509aae..7bd2cce4 100644 --- a/test/test_crc16_mcrf4xx.cpp +++ b/test/test_crc16_mcrf4xx.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_mcrf4xx_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_modbus.cpp b/test/test_crc16_modbus.cpp index e747a9ea..819c395b 100644 --- a/test/test_crc16_modbus.cpp +++ b/test/test_crc16_modbus.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_modbus_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_opensafety_a.cpp b/test/test_crc16_opensafety_a.cpp index dbf2804b..48981168 100644 --- a/test/test_crc16_opensafety_a.cpp +++ b/test/test_crc16_opensafety_a.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_opensafety_a_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_opensafety_b.cpp b/test/test_crc16_opensafety_b.cpp index 523d41bf..de9e059c 100644 --- a/test/test_crc16_opensafety_b.cpp +++ b/test/test_crc16_opensafety_b.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_opensafety_b_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_profibus.cpp b/test/test_crc16_profibus.cpp index a7e3f301..1d57eeb7 100644 --- a/test/test_crc16_profibus.cpp +++ b/test/test_crc16_profibus.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_profibus_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_riello.cpp b/test/test_crc16_riello.cpp index 319b0a84..2965e152 100644 --- a/test/test_crc16_riello.cpp +++ b/test/test_crc16_riello.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_riello_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_t10dif.cpp b/test/test_crc16_t10dif.cpp index 570b9935..312289db 100644 --- a/test/test_crc16_t10dif.cpp +++ b/test/test_crc16_t10dif.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_t10dif_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_teledisk.cpp b/test/test_crc16_teledisk.cpp index 69135f08..f50fa2ff 100644 --- a/test/test_crc16_teledisk.cpp +++ b/test/test_crc16_teledisk.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_teledisk_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_tms37157.cpp b/test/test_crc16_tms37157.cpp index 12733b0f..fbb474c9 100644 --- a/test/test_crc16_tms37157.cpp +++ b/test/test_crc16_tms37157.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_tms37157_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_usb.cpp b/test/test_crc16_usb.cpp index e3249443..ac06985f 100644 --- a/test/test_crc16_usb.cpp +++ b/test/test_crc16_usb.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_usb_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_x25.cpp b/test/test_crc16_x25.cpp index 42799814..2b434f32 100644 --- a/test/test_crc16_x25.cpp +++ b/test/test_crc16_x25.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_x25_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc16_xmodem.cpp b/test/test_crc16_xmodem.cpp index 4630f438..5b0c0bf3 100644 --- a/test/test_crc16_xmodem.cpp +++ b/test/test_crc16_xmodem.cpp @@ -316,6 +316,6 @@ namespace uint16_t crc3 = etl::crc16_xmodem_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32.cpp b/test/test_crc32.cpp index e8ce34e0..89ecf035 100644 --- a/test/test_crc32.cpp +++ b/test/test_crc32.cpp @@ -305,6 +305,6 @@ namespace uint32_t crc3 = etl::crc32_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_bzip2.cpp b/test/test_crc32_bzip2.cpp index 262f471e..bbffb555 100644 --- a/test/test_crc32_bzip2.cpp +++ b/test/test_crc32_bzip2.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_bzip2_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_c.cpp b/test/test_crc32_c.cpp index 65e4de2d..40802124 100644 --- a/test/test_crc32_c.cpp +++ b/test/test_crc32_c.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_c_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_d.cpp b/test/test_crc32_d.cpp index 8b68d0c6..484478ac 100644 --- a/test/test_crc32_d.cpp +++ b/test/test_crc32_d.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_d_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_jamcrc.cpp b/test/test_crc32_jamcrc.cpp index 29f2285f..316f4c85 100644 --- a/test/test_crc32_jamcrc.cpp +++ b/test/test_crc32_jamcrc.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_jamcrc_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_mpeg2.cpp b/test/test_crc32_mpeg2.cpp index 3826e065..b0e700c7 100644 --- a/test/test_crc32_mpeg2.cpp +++ b/test/test_crc32_mpeg2.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_mpeg2_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_posix.cpp b/test/test_crc32_posix.cpp index fd3101e0..54fab698 100644 --- a/test/test_crc32_posix.cpp +++ b/test/test_crc32_posix.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_posix_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_q.cpp b/test/test_crc32_q.cpp index 92e20e07..bc1ed5ee 100644 --- a/test/test_crc32_q.cpp +++ b/test/test_crc32_q.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_q_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc32_xfer.cpp b/test/test_crc32_xfer.cpp index 95510fb0..301e9f11 100644 --- a/test/test_crc32_xfer.cpp +++ b/test/test_crc32_xfer.cpp @@ -316,6 +316,6 @@ namespace uint32_t crc3 = etl::crc32_xfer_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc64_ecma.cpp b/test/test_crc64_ecma.cpp index dea9430b..b73111d2 100644 --- a/test/test_crc64_ecma.cpp +++ b/test/test_crc64_ecma.cpp @@ -316,6 +316,6 @@ namespace uint64_t crc3 = etl::crc64_ecma_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc64_iso.cpp b/test/test_crc64_iso.cpp index dc87ebdd..869db18d 100644 --- a/test/test_crc64_iso.cpp +++ b/test/test_crc64_iso.cpp @@ -316,6 +316,6 @@ namespace uint64_t crc3 = etl::crc64_iso_t4(data3.rbegin(), data3.rend()); CHECK_EQUAL(crc1, crc3); } - }; + } } diff --git a/test/test_crc8_ccitt.cpp b/test/test_crc8_ccitt.cpp index d71ee2ff..fda367a7 100644 --- a/test/test_crc8_ccitt.cpp +++ b/test/test_crc8_ccitt.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_ccitt(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_cdma2000.cpp b/test/test_crc8_cdma2000.cpp index 71a5b24d..67b7b4f5 100644 --- a/test/test_crc8_cdma2000.cpp +++ b/test/test_crc8_cdma2000.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_cdma2000(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_darc.cpp b/test/test_crc8_darc.cpp index adfef170..944f7f88 100644 --- a/test/test_crc8_darc.cpp +++ b/test/test_crc8_darc.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_darc(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_dvbs2.cpp b/test/test_crc8_dvbs2.cpp index ea13c3e9..19a14e4b 100644 --- a/test/test_crc8_dvbs2.cpp +++ b/test/test_crc8_dvbs2.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_dvbs2(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_ebu.cpp b/test/test_crc8_ebu.cpp index 065498dd..80f71074 100644 --- a/test/test_crc8_ebu.cpp +++ b/test/test_crc8_ebu.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_ebu(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_icode.cpp b/test/test_crc8_icode.cpp index 33403afd..de3a43cf 100644 --- a/test/test_crc8_icode.cpp +++ b/test/test_crc8_icode.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_icode(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_itu.cpp b/test/test_crc8_itu.cpp index 02924153..d6d4f678 100644 --- a/test/test_crc8_itu.cpp +++ b/test/test_crc8_itu.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_itu(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_j1850.cpp b/test/test_crc8_j1850.cpp index e0a6b325..5567ef11 100644 --- a/test/test_crc8_j1850.cpp +++ b/test/test_crc8_j1850.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_j1850(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_j1850_zero.cpp b/test/test_crc8_j1850_zero.cpp index 0e37afbb..2abde07e 100644 --- a/test/test_crc8_j1850_zero.cpp +++ b/test/test_crc8_j1850_zero.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_j1850_zero(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_maxim.cpp b/test/test_crc8_maxim.cpp index e06f5497..b65fcc6c 100644 --- a/test/test_crc8_maxim.cpp +++ b/test/test_crc8_maxim.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_maxim(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_nrsc5.cpp b/test/test_crc8_nrsc5.cpp index db109988..45835e7a 100644 --- a/test/test_crc8_nrsc5.cpp +++ b/test/test_crc8_nrsc5.cpp @@ -291,6 +291,6 @@ namespace uint8_t crc3 = etl::crc8_nrsc5(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_opensafety.cpp b/test/test_crc8_opensafety.cpp index 913ce7ba..608852fd 100644 --- a/test/test_crc8_opensafety.cpp +++ b/test/test_crc8_opensafety.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_opensafety(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_rohc.cpp b/test/test_crc8_rohc.cpp index 84f49726..d2da2cde 100644 --- a/test/test_crc8_rohc.cpp +++ b/test/test_crc8_rohc.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_rohc(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_crc8_wcdma.cpp b/test/test_crc8_wcdma.cpp index 2c591e3c..33b44686 100644 --- a/test/test_crc8_wcdma.cpp +++ b/test/test_crc8_wcdma.cpp @@ -316,6 +316,6 @@ namespace uint8_t crc3 = etl::crc8_wcdma(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(crc1), int(crc3)); } - }; + } } diff --git a/test/test_cyclic_value.cpp b/test/test_cyclic_value.cpp index f1f9e193..109a2b38 100644 --- a/test/test_cyclic_value.cpp +++ b/test/test_cyclic_value.cpp @@ -492,5 +492,5 @@ namespace CHECK(data1 == compare2); CHECK(data2 == compare1); } - }; + } } diff --git a/test/test_debounce.cpp b/test/test_debounce.cpp index a56b07ca..868739b1 100644 --- a/test/test_debounce.cpp +++ b/test/test_debounce.cpp @@ -875,5 +875,5 @@ namespace CHECK(key_state.add(false)); CHECK(!key_state.is_set()); } - }; + } } diff --git a/test/test_delegate.cpp b/test/test_delegate.cpp index 165c0250..57c52e86 100644 --- a/test/test_delegate.cpp +++ b/test/test_delegate.cpp @@ -112,7 +112,7 @@ namespace //***************************************************************************** void free_int(int i, int j) { - function_called = FunctionCalled::Free_Int_Called;; + function_called = FunctionCalled::Free_Int_Called; parameter_correct = (i == VALUE1) && (j == VALUE2); } @@ -1822,7 +1822,7 @@ namespace Object object; auto d1 = etl::delegate::create(object); - auto d2 = etl::delegate::create(object);; + auto d2 = etl::delegate::create(object); CHECK(d1 != d2); } @@ -2019,7 +2019,7 @@ namespace (void)d; } #endif - }; + } } #endif diff --git a/test/test_delegate_cpp03.cpp b/test/test_delegate_cpp03.cpp index 3a220de3..6aeb43cc 100644 --- a/test/test_delegate_cpp03.cpp +++ b/test/test_delegate_cpp03.cpp @@ -773,7 +773,7 @@ namespace Object object; auto d1 = etl_cpp03::delegate::create(object); - auto d2 = etl_cpp03::delegate::create(object);; + auto d2 = etl_cpp03::delegate::create(object); CHECK(d1 != d2); } @@ -920,5 +920,5 @@ namespace CHECK(*itr != d2); CHECK(*itr == d3); } - }; + } } diff --git a/test/test_delegate_observable.cpp b/test/test_delegate_observable.cpp index 914d97f6..a056b1b6 100644 --- a/test/test_delegate_observable.cpp +++ b/test/test_delegate_observable.cpp @@ -274,7 +274,7 @@ namespace CHECK_EQUAL(3, global_value); CHECK_EQUAL(4, member_value); } - }; + } } #endif diff --git a/test/test_delegate_service.cpp b/test/test_delegate_service.cpp index a9aa858e..d6745a3c 100644 --- a/test/test_delegate_service.cpp +++ b/test/test_delegate_service.cpp @@ -331,7 +331,7 @@ namespace CHECK(!member2_called); CHECK(unhandled_called); } - }; + } } #endif diff --git a/test/test_delegate_service_compile_time.cpp b/test/test_delegate_service_compile_time.cpp index c97db964..7c688eda 100644 --- a/test/test_delegate_service_compile_time.cpp +++ b/test/test_delegate_service_compile_time.cpp @@ -159,7 +159,7 @@ namespace CHECK(!member_called); CHECK(unhandled_called); } - }; + } } #endif diff --git a/test/test_delegate_service_cpp03.cpp b/test/test_delegate_service_cpp03.cpp index cd2caae8..da372392 100644 --- a/test/test_delegate_service_cpp03.cpp +++ b/test/test_delegate_service_cpp03.cpp @@ -331,7 +331,7 @@ namespace CHECK(!member2_called); CHECK(unhandled_called); } - }; + } } #endif diff --git a/test/test_deque.cpp b/test/test_deque.cpp index dcd9558b..a1b0fa15 100644 --- a/test/test_deque.cpp +++ b/test/test_deque.cpp @@ -2263,7 +2263,7 @@ namespace CHECK(std::equal(blank_data.begin(), blank_data.end(), data.begin())); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_endian.cpp b/test/test_endian.cpp index a0c7720f..8d7529ee 100644 --- a/test/test_endian.cpp +++ b/test/test_endian.cpp @@ -61,5 +61,5 @@ namespace #error Endianness unknown: Test not possible #endif } - }; + } } diff --git a/test/test_enum_type.cpp b/test/test_enum_type.cpp index f51f4ead..42b39c3a 100644 --- a/test/test_enum_type.cpp +++ b/test/test_enum_type.cpp @@ -150,5 +150,5 @@ namespace CHECK_EQUAL(expected, actual.get_enum()); } - }; + } } diff --git a/test/test_error_handler.cpp b/test/test_error_handler.cpp index a8fba63e..c060f238 100644 --- a/test/test_error_handler.cpp +++ b/test/test_error_handler.cpp @@ -188,5 +188,5 @@ namespace CHECK(error_received); } - }; + } } diff --git a/test/test_etl_assert.cpp b/test/test_etl_assert.cpp index 2df84d31..e927a0b2 100644 --- a/test/test_etl_assert.cpp +++ b/test/test_etl_assert.cpp @@ -67,5 +67,5 @@ namespace CHECK_THROW(ETL_ASSERT(false, ETL_ERROR_GENERIC("Generic Assert Exception")), etl::exception); CHECK_NO_THROW(ETL_ASSERT(true, ETL_ERROR_GENERIC("Generic Assert Exception"))); } - }; + } } diff --git a/test/test_etl_traits.cpp b/test/test_etl_traits.cpp index fa1c700d..f61b2831 100644 --- a/test/test_etl_traits.cpp +++ b/test/test_etl_traits.cpp @@ -110,5 +110,5 @@ namespace CHECK_ARRAY_EQUAL(ETL_VERSION, etl::traits::version_u16string, etl::strlen(ETL_VERSION_U16)); CHECK_ARRAY_EQUAL(ETL_VERSION, etl::traits::version_u32string, etl::strlen(ETL_VERSION_U32)); } - }; + } } diff --git a/test/test_exception.cpp b/test/test_exception.cpp index fde141cc..0a57804f 100644 --- a/test/test_exception.cpp +++ b/test/test_exception.cpp @@ -61,5 +61,5 @@ namespace CHECK_EQUAL(123, c.line_number()); } } - }; + } } diff --git a/test/test_expected.cpp b/test/test_expected.cpp index d7df3577..e71a218a 100644 --- a/test/test_expected.cpp +++ b/test/test_expected.cpp @@ -792,5 +792,5 @@ namespace CHECK_TRUE(test_unexp_1_swap == test_unexp_2); CHECK_TRUE(test_unexp_2_swap == test_unexp_1); } - }; + } } diff --git a/test/test_fixed_iterator.cpp b/test/test_fixed_iterator.cpp index e440ed18..b35f9221 100644 --- a/test/test_fixed_iterator.cpp +++ b/test/test_fixed_iterator.cpp @@ -228,5 +228,5 @@ namespace CHECK(fi1 == fi2); CHECK(fi1 != fi3); } - }; + } } diff --git a/test/test_flags.cpp b/test/test_flags.cpp index acb33e7b..231c96ac 100644 --- a/test/test_flags.cpp +++ b/test/test_flags.cpp @@ -610,5 +610,5 @@ namespace CHECK_EQUAL(int(FNONE), int(flags3 ^= F01234567)); CHECK_EQUAL(int(F0246), int(flags4 ^= FNONE)); } - }; + } } diff --git a/test/test_flat_map.cpp b/test/test_flat_map.cpp index 272ebe10..d60d2e6d 100644 --- a/test/test_flat_map.cpp +++ b/test/test_flat_map.cpp @@ -1555,5 +1555,5 @@ namespace CHECK(data.contains(Key(1))); CHECK(!data.contains(Key(99))); } - }; + } } diff --git a/test/test_flat_multimap.cpp b/test/test_flat_multimap.cpp index 50999b56..b3358d18 100644 --- a/test/test_flat_multimap.cpp +++ b/test/test_flat_multimap.cpp @@ -1364,5 +1364,5 @@ namespace CHECK(data.contains(Key(1))); CHECK(!data.contains(Key(99))); } - }; + } } diff --git a/test/test_flat_multiset.cpp b/test/test_flat_multiset.cpp index 057a0ab3..52147a66 100644 --- a/test/test_flat_multiset.cpp +++ b/test/test_flat_multiset.cpp @@ -1356,5 +1356,5 @@ namespace CHECK(data.contains(Key(N5))); CHECK(!data.contains(Key(NX))); } - }; + } } diff --git a/test/test_flat_set.cpp b/test/test_flat_set.cpp index 5c380b02..c2016ad1 100644 --- a/test/test_flat_set.cpp +++ b/test/test_flat_set.cpp @@ -1316,5 +1316,5 @@ namespace CHECK(data.contains(Key(N5))); CHECK(!data.contains(Key(NX))); } - }; + } } diff --git a/test/test_fnv_1.cpp b/test/test_fnv_1.cpp index a3f866e3..ad8091b6 100644 --- a/test/test_fnv_1.cpp +++ b/test/test_fnv_1.cpp @@ -351,6 +351,6 @@ namespace uint64_t hash3 = etl::fnv_1a_64(data3.rbegin(), data3.rend()); CHECK_EQUAL(int(hash1), int(hash3)); } - }; + } } diff --git a/test/test_format_spec.cpp b/test/test_format_spec.cpp index eadf3ab0..57eb0841 100644 --- a/test/test_format_spec.cpp +++ b/test/test_format_spec.cpp @@ -118,6 +118,6 @@ namespace CHECK_EQUAL(true, upper_case); } #endif - }; + } } diff --git a/test/test_forward_list.cpp b/test/test_forward_list.cpp index 494b69c7..d7b44bf7 100644 --- a/test/test_forward_list.cpp +++ b/test/test_forward_list.cpp @@ -1419,5 +1419,5 @@ namespace CHECK_EQUAL(ItemNDC("F"), *itr++); } #endif - }; + } } diff --git a/test/test_forward_list_shared_pool.cpp b/test/test_forward_list_shared_pool.cpp index 6500805a..39d7a201 100644 --- a/test/test_forward_list_shared_pool.cpp +++ b/test/test_forward_list_shared_pool.cpp @@ -1926,5 +1926,5 @@ namespace CHECK(data1 < data3); CHECK(data3 > data1); } - }; + } } diff --git a/test/test_fsm.cpp b/test/test_fsm.cpp index 54745f3b..c6a34e8e 100644 --- a/test/test_fsm.cpp +++ b/test/test_fsm.cpp @@ -780,5 +780,5 @@ namespace CHECK_EQUAL(StateId::Locked, int(motorControl.get_state_id())); CHECK_EQUAL(StateId::Locked, int(motorControl.get_state().get_state_id())); } - }; + } } diff --git a/test/test_function.cpp b/test/test_function.cpp index c64f81ca..5b19ce36 100644 --- a/test/test_function.cpp +++ b/test/test_function.cpp @@ -506,5 +506,5 @@ namespace CHECK(function_called); } - }; + } } diff --git a/test/test_function_traits.cpp b/test/test_function_traits.cpp index 56024198..bd6448f0 100644 --- a/test/test_function_traits.cpp +++ b/test/test_function_traits.cpp @@ -448,7 +448,7 @@ namespace long operator()(int a, const std::string& s) { return static_cast(a + s.size()); - }; + } }; using traits = etl::function_traits; @@ -530,5 +530,5 @@ namespace CHECK_EQUAL(1, traits_f::arity); CHECK_EQUAL(1, traits_cf::arity); } - }; + } } diff --git a/test/test_functional.cpp b/test/test_functional.cpp index 9970cf25..1204d330 100644 --- a/test/test_functional.cpp +++ b/test/test_functional.cpp @@ -379,5 +379,5 @@ namespace result = f3(mft, "Arg1", " : Arg2"); CHECK_EQUAL("Function3_Const: Arg1 : Arg2", result); } - }; + } } diff --git a/test/test_gamma.cpp b/test/test_gamma.cpp index 579bf58d..2d2568a6 100644 --- a/test/test_gamma.cpp +++ b/test/test_gamma.cpp @@ -95,5 +95,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2b.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_hash.cpp b/test/test_hash.cpp index 53567505..4c2c8acf 100644 --- a/test/test_hash.cpp +++ b/test/test_hash.cpp @@ -317,6 +317,6 @@ namespace CHECK_TRUE(std::is_copy_assignable::value); CHECK_TRUE(std::is_move_assignable::value); } - }; + } } diff --git a/test/test_hfsm.cpp b/test/test_hfsm.cpp index 30e422e7..b473d016 100644 --- a/test/test_hfsm.cpp +++ b/test/test_hfsm.cpp @@ -1087,5 +1087,5 @@ namespace } - }; + } } diff --git a/test/test_hfsm_recurse_to_inner_state_on_start.cpp b/test/test_hfsm_recurse_to_inner_state_on_start.cpp index 7e172ac2..1c8c7c74 100644 --- a/test/test_hfsm_recurse_to_inner_state_on_start.cpp +++ b/test/test_hfsm_recurse_to_inner_state_on_start.cpp @@ -256,5 +256,5 @@ namespace CHECK_EQUAL(StateId::State1_1_1, stateMachine.get_state_id()); } - }; + } } diff --git a/test/test_histogram.cpp b/test/test_histogram.cpp index c682c723..056f67c2 100644 --- a/test/test_histogram.cpp +++ b/test/test_histogram.cpp @@ -376,5 +376,5 @@ namespace isEqual = std::equal(output2.begin(), output2.end(), histogram.begin()); CHECK(isEqual); } - }; + } } diff --git a/test/test_indirect_vector.cpp b/test/test_indirect_vector.cpp index bcc3b08d..cd639a6b 100644 --- a/test/test_indirect_vector.cpp +++ b/test/test_indirect_vector.cpp @@ -1553,5 +1553,5 @@ namespace CHECK(std::equal(blank_data.begin(), blank_data.end(), data.begin())); } - }; + } } diff --git a/test/test_indirect_vector_external_buffer.cpp b/test/test_indirect_vector_external_buffer.cpp index 7911eabd..4ce54e75 100644 --- a/test/test_indirect_vector_external_buffer.cpp +++ b/test/test_indirect_vector_external_buffer.cpp @@ -1700,5 +1700,5 @@ namespace CHECK(is_equal); } - }; + } } diff --git a/test/test_instance_count.cpp b/test/test_instance_count.cpp index 654c48eb..57229996 100644 --- a/test/test_instance_count.cpp +++ b/test/test_instance_count.cpp @@ -106,5 +106,5 @@ namespace CHECK_EQUAL(2, Test1::get_instance_count()); CHECK_EQUAL(2, Test2::get_instance_count()); } - }; + } } diff --git a/test/test_integral_limits.cpp b/test/test_integral_limits.cpp index 9fcba6d8..f5928fc6 100644 --- a/test/test_integral_limits.cpp +++ b/test/test_integral_limits.cpp @@ -101,5 +101,5 @@ namespace CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); CHECK_EQUAL(std::numeric_limits::is_signed, (bool)etl::integral_limits::is_signed); } - }; + } } diff --git a/test/test_intrusive_forward_list.cpp b/test/test_intrusive_forward_list.cpp index da4d185c..4bb3d6f3 100644 --- a/test/test_intrusive_forward_list.cpp +++ b/test/test_intrusive_forward_list.cpp @@ -1358,5 +1358,5 @@ namespace CHECK_FALSE(data0.contains(compare_node2)); } - }; + } } diff --git a/test/test_intrusive_links.cpp b/test/test_intrusive_links.cpp index 2b8d0445..c5bb92c8 100644 --- a/test/test_intrusive_links.cpp +++ b/test/test_intrusive_links.cpp @@ -1730,5 +1730,5 @@ namespace CHECK(a.etl_left == nullptr); CHECK(a.etl_right == &c); } - }; + } } diff --git a/test/test_intrusive_list.cpp b/test/test_intrusive_list.cpp index c997c610..41ea478f 100644 --- a/test/test_intrusive_list.cpp +++ b/test/test_intrusive_list.cpp @@ -1610,5 +1610,5 @@ namespace CHECK_FALSE(data0.contains(compare_node2)); } - }; + } } diff --git a/test/test_intrusive_queue.cpp b/test/test_intrusive_queue.cpp index 8b44f343..8ab16536 100644 --- a/test/test_intrusive_queue.cpp +++ b/test/test_intrusive_queue.cpp @@ -438,5 +438,5 @@ namespace queueD.pop(); CHECK_EQUAL(queueD.back(), queueDR.back()); } - }; + } } diff --git a/test/test_intrusive_stack.cpp b/test/test_intrusive_stack.cpp index 282d887a..ad55b635 100644 --- a/test/test_intrusive_stack.cpp +++ b/test/test_intrusive_stack.cpp @@ -328,5 +328,5 @@ namespace CHECK_EQUAL(stack.top(), data5); } - }; + } } diff --git a/test/test_invert.cpp b/test/test_invert.cpp index c39d023e..41f80bca 100644 --- a/test/test_invert.cpp +++ b/test/test_invert.cpp @@ -130,5 +130,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2b.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_io_port.cpp b/test/test_io_port.cpp index a4e4c0a1..ed359695 100644 --- a/test/test_io_port.cpp +++ b/test/test_io_port.cpp @@ -523,5 +523,5 @@ namespace CHECK_EQUAL(iop1.read(), *itr4); CHECK_EQUAL(iop2.read(), *itr3); } - }; + } } diff --git a/test/test_iterator.cpp b/test/test_iterator.cpp index c777574d..14f0d878 100644 --- a/test/test_iterator.cpp +++ b/test/test_iterator.cpp @@ -580,5 +580,5 @@ namespace // CHECK_EQUAL(expected.size(), output.size()); // CHECK(std::equal(output.begin(), output.end(), expected.begin())); //} - }; + } } diff --git a/test/test_jenkins.cpp b/test/test_jenkins.cpp index ed00abda..86d21569 100644 --- a/test/test_jenkins.cpp +++ b/test/test_jenkins.cpp @@ -164,6 +164,6 @@ namespace CHECK_THROW(j32.add(0), etl::hash_finalized); } - }; + } } diff --git a/test/test_largest.cpp b/test/test_largest.cpp index df6aef02..d36882ec 100644 --- a/test/test_largest.cpp +++ b/test/test_largest.cpp @@ -251,5 +251,5 @@ namespace CHECK(bool(etl::is_same, uint64_t>::value)); CHECK(bool(etl::is_same, uint64_t>::value)); } - }; + } } diff --git a/test/test_limiter.cpp b/test/test_limiter.cpp index 0ad36b9d..e4f31720 100644 --- a/test/test_limiter.cpp +++ b/test/test_limiter.cpp @@ -98,5 +98,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2a.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_limits.cpp b/test/test_limits.cpp index 8c120454..28fda31d 100644 --- a/test/test_limits.cpp +++ b/test/test_limits.cpp @@ -730,5 +730,5 @@ namespace CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); } - }; + } } diff --git a/test/test_list.cpp b/test/test_list.cpp index baed08a0..003fb853 100644 --- a/test/test_list.cpp +++ b/test/test_list.cpp @@ -2233,5 +2233,5 @@ namespace CHECK_EQUAL(ItemNDC("F"), *itr++); } #endif - }; + } } diff --git a/test/test_list_shared_pool.cpp b/test/test_list_shared_pool.cpp index e87203d9..802d15dc 100644 --- a/test/test_list_shared_pool.cpp +++ b/test/test_list_shared_pool.cpp @@ -2224,5 +2224,5 @@ namespace CHECK_THROW(data0.merge(data1), etl::list_unsorted); } - }; + } } diff --git a/test/test_macros.cpp b/test/test_macros.cpp index cf8be527..c57d876b 100644 --- a/test/test_macros.cpp +++ b/test/test_macros.cpp @@ -57,5 +57,5 @@ namespace CHECK_ARRAY_EQUAL(u"ABCDEF", ETL_U16_STRING(ABCDEF), etl::strlen(u"ABCDEF")); CHECK_ARRAY_EQUAL(U"ABCDEF", ETL_U32_STRING(ABCDEF), etl::strlen(U"ABCDEF")); } - }; + } } diff --git a/test/test_make_string.cpp b/test/test_make_string.cpp index f24b95d9..06b2b540 100644 --- a/test/test_make_string.cpp +++ b/test/test_make_string.cpp @@ -144,9 +144,9 @@ namespace #if ETL_HAS_ERROR_ON_STRING_TRUNCATION CHECK_THROW(auto ctext = etl::make_string_with_capacity("Hello World"), etl::string_truncation); - CHECK_THROW(auto wtext = etl::make_string_with_capacity(L"Hello World"), etl::string_truncation);; - CHECK_THROW(auto u16text = etl::make_string_with_capacity(u"Hello World"), etl::string_truncation);; - CHECK_THROW(auto u32text = etl::make_string_with_capacity(U"Hello World"), etl::string_truncation);; + CHECK_THROW(auto wtext = etl::make_string_with_capacity(L"Hello World"), etl::string_truncation); + CHECK_THROW(auto u16text = etl::make_string_with_capacity(u"Hello World"), etl::string_truncation); + CHECK_THROW(auto u32text = etl::make_string_with_capacity(U"Hello World"), etl::string_truncation); #else size_t length = strlen("Hello World"); @@ -185,5 +185,5 @@ namespace CHECK(Equal(std::u32string(U"Hello Worl"), ctext)); #endif } - }; + } } diff --git a/test/test_map.cpp b/test/test_map.cpp index c2e4527c..b5ca6447 100644 --- a/test/test_map.cpp +++ b/test/test_map.cpp @@ -1634,5 +1634,5 @@ namespace CHECK(!data.contains(std::string("99"))); CHECK(!data.contains(Key("99"))); } - }; + } } diff --git a/test/test_math.cpp b/test/test_math.cpp index ede19aa6..880768c4 100644 --- a/test/test_math.cpp +++ b/test/test_math.cpp @@ -130,5 +130,5 @@ namespace CHECK_TRUE(etl::is_exactly_equal(i1, i1)); CHECK_FALSE(etl::is_exactly_equal(i1, i2)); } - }; + } } diff --git a/test/test_math_functions.cpp b/test/test_math_functions.cpp index 40594351..0b7c9205 100644 --- a/test/test_math_functions.cpp +++ b/test/test_math_functions.cpp @@ -587,5 +587,5 @@ namespace CHECK_EQUAL(uint16_t(0), absolute5); CHECK_EQUAL(uint16_t(65535), absolute6); } - }; + } } diff --git a/test/test_mean.cpp b/test/test_mean.cpp index 1be97dc5..af225b34 100644 --- a/test/test_mean.cpp +++ b/test/test_mean.cpp @@ -112,5 +112,5 @@ namespace mean_result = mean1.get_mean(); CHECK_CLOSE(4.5, mean_result, 0.1); } - }; + } } diff --git a/test/test_mem_cast.cpp b/test/test_mem_cast.cpp index 406231e9..8090525d 100644 --- a/test/test_mem_cast.cpp +++ b/test/test_mem_cast.cpp @@ -340,5 +340,5 @@ namespace CHECK_EQUAL(2, memCastTypes.ref().a[1]); CHECK_EQUAL(3, memCastTypes.ref().a[2]); } - }; + } } diff --git a/test/test_mem_cast_ptr.cpp b/test/test_mem_cast_ptr.cpp index 90ce4930..973a345d 100644 --- a/test/test_mem_cast_ptr.cpp +++ b/test/test_mem_cast_ptr.cpp @@ -397,5 +397,5 @@ namespace CHECK_THROW(c = memCast.ref(), etl::mem_cast_nullptr_exception); CHECK(c == 0); } - }; + } } diff --git a/test/test_memory.cpp b/test/test_memory.cpp index 8fc7e628..59e66e3a 100644 --- a/test/test_memory.cpp +++ b/test/test_memory.cpp @@ -1447,7 +1447,7 @@ namespace class Base { public: - virtual ~Base() {}; + virtual ~Base() {} virtual void function() = 0; }; @@ -1699,5 +1699,5 @@ namespace CHECK_EQUAL(&i, etl::to_address(pi)); CHECK_EQUAL(plist_item, etl::to_address(itr)); } - }; + } } diff --git a/test/test_message.cpp b/test/test_message.cpp index 1e28b1f0..d51584f0 100644 --- a/test/test_message.cpp +++ b/test/test_message.cpp @@ -129,4 +129,4 @@ SUITE(test_message) CHECK_FALSE((std::is_same::value)); CHECK_FALSE((std::is_same::value)); } -}; +} diff --git a/test/test_message_broker.cpp b/test/test_message_broker.cpp index fda9ae16..faa74539 100644 --- a/test/test_message_broker.cpp +++ b/test/test_message_broker.cpp @@ -558,5 +558,5 @@ namespace CHECK_TRUE(broker.accepts(MESSAGE5)); CHECK_TRUE(broker.accepts(MESSAGE6)); } - }; + } } diff --git a/test/test_message_bus.cpp b/test/test_message_bus.cpp index e7fde856..2dfe8964 100644 --- a/test/test_message_bus.cpp +++ b/test/test_message_bus.cpp @@ -1007,5 +1007,5 @@ namespace CHECK_TRUE(bus1.accepts(MESSAGE6)); CHECK_FALSE(bus1.accepts(MESSAGE7)); } - }; + } } diff --git a/test/test_message_packet.cpp b/test/test_message_packet.cpp index a13830c8..206d9f8c 100644 --- a/test/test_message_packet.cpp +++ b/test/test_message_packet.cpp @@ -487,5 +487,5 @@ namespace obj.Push(packet1); obj.Push(packet2); } - }; + } } diff --git a/test/test_message_router.cpp b/test/test_message_router.cpp index 43bf1174..e7d94ac1 100644 --- a/test/test_message_router.cpp +++ b/test/test_message_router.cpp @@ -733,5 +733,5 @@ namespace CHECK_FALSE(router.unknown_message_received); } - }; + } } diff --git a/test/test_message_router_registry.cpp b/test/test_message_router_registry.cpp index 8819b6a3..6dbdcb46 100644 --- a/test/test_message_router_registry.cpp +++ b/test/test_message_router_registry.cpp @@ -392,5 +392,5 @@ namespace CHECK_EQUAL(ROUTER1, (*citr).get_message_router_id()); CHECK_EQUAL(ROUTER1, citr->get_message_router_id()); } - }; + } } diff --git a/test/test_message_timer.cpp b/test/test_message_timer.cpp index 1e4eca2e..9c137805 100644 --- a/test/test_message_timer.cpp +++ b/test/test_message_timer.cpp @@ -819,5 +819,5 @@ namespace CHECK(router1.message2.size() < 65U); } #endif - }; + } } diff --git a/test/test_message_timer_atomic.cpp b/test/test_message_timer_atomic.cpp index b612cd46..87e264b3 100644 --- a/test/test_message_timer_atomic.cpp +++ b/test/test_message_timer_atomic.cpp @@ -819,5 +819,5 @@ namespace CHECK(router1.message2.size() < 65U); } #endif - }; + } } diff --git a/test/test_message_timer_interrupt.cpp b/test/test_message_timer_interrupt.cpp index 7c66edb9..a1771bf1 100644 --- a/test/test_message_timer_interrupt.cpp +++ b/test/test_message_timer_interrupt.cpp @@ -902,5 +902,5 @@ namespace // Check the CHECK_EQUAL(0U, ScopedGuard::guard_count); } - }; + } } diff --git a/test/test_message_timer_locked.cpp b/test/test_message_timer_locked.cpp index 6d7c1215..888434c0 100644 --- a/test/test_message_timer_locked.cpp +++ b/test/test_message_timer_locked.cpp @@ -958,5 +958,5 @@ namespace CHECK_EQUAL(0U, locks.lock_count); } #endif - }; + } } diff --git a/test/test_multi_array.cpp b/test/test_multi_array.cpp index 00c8670c..08085efb 100644 --- a/test/test_multi_array.cpp +++ b/test/test_multi_array.cpp @@ -488,5 +488,5 @@ namespace CHECK(data >= data); CHECK(!(lesser >= data)); } - }; + } } diff --git a/test/test_multi_range.cpp b/test/test_multi_range.cpp index a72177c5..82604d98 100644 --- a/test/test_multi_range.cpp +++ b/test/test_multi_range.cpp @@ -431,5 +431,5 @@ namespace outer.detach_all(); } - }; + } } diff --git a/test/test_multi_span.cpp b/test/test_multi_span.cpp index 19fbee95..2c150e35 100644 --- a/test/test_multi_span.cpp +++ b/test/test_multi_span.cpp @@ -761,5 +761,5 @@ namespace CHECK_EQUAL(expected[i], ms_int[i]); } } - }; + } } diff --git a/test/test_multi_vector.cpp b/test/test_multi_vector.cpp index 05efd8d4..322b84b1 100644 --- a/test/test_multi_vector.cpp +++ b/test/test_multi_vector.cpp @@ -574,5 +574,5 @@ namespace CHECK(data >= data); CHECK(!(lesser >= data)); } - }; + } } diff --git a/test/test_multimap.cpp b/test/test_multimap.cpp index a6a29e03..667cccea 100644 --- a/test/test_multimap.cpp +++ b/test/test_multimap.cpp @@ -1691,5 +1691,5 @@ namespace CHECK(!data.contains(std::string("99"))); CHECK(!data.contains(Key("99"))); } - }; + } } diff --git a/test/test_multiset.cpp b/test/test_multiset.cpp index aae2b234..47bca6e1 100644 --- a/test/test_multiset.cpp +++ b/test/test_multiset.cpp @@ -1621,5 +1621,5 @@ namespace CHECK(!data.contains(99)); CHECK(!data.contains(Key(99))); } - }; + } } diff --git a/test/test_murmur3.cpp b/test/test_murmur3.cpp index 24a91dd3..a6fd62ff 100644 --- a/test/test_murmur3.cpp +++ b/test/test_murmur3.cpp @@ -135,6 +135,6 @@ namespace MurmurHash3_x86_32((uint8_t*)&data2[0], data2.size() * sizeof(uint32_t), 0, &compare2); CHECK_EQUAL(compare2, hash2); } - }; + } } diff --git a/test/test_not_null_pointer.cpp b/test/test_not_null_pointer.cpp index d9835846..fd6eb4ed 100644 --- a/test/test_not_null_pointer.cpp +++ b/test/test_not_null_pointer.cpp @@ -160,5 +160,5 @@ namespace CHECK_FALSE(nn1 >= nn2); CHECK_TRUE(nn2 >= nn1); } - }; + } } \ No newline at end of file diff --git a/test/test_not_null_pointer_constexpr.cpp b/test/test_not_null_pointer_constexpr.cpp index 5cf53881..9ca9f524 100644 --- a/test/test_not_null_pointer_constexpr.cpp +++ b/test/test_not_null_pointer_constexpr.cpp @@ -148,7 +148,7 @@ namespace CHECK_EQUAL(s.x, x1); CHECK_EQUAL(s.get(), x2); } - }; + } } #endif diff --git a/test/test_numeric.cpp b/test/test_numeric.cpp index 8cb8b238..6d8a0802 100644 --- a/test/test_numeric.cpp +++ b/test/test_numeric.cpp @@ -204,5 +204,5 @@ namespace CHECK_CLOSE(10.0, etl::lerp(10.0, 10.0, 1), 0.001); CHECK_CLOSE(10.0, etl::lerp(10, 10, 1), 0.001); } - }; + } } diff --git a/test/test_optional.cpp b/test/test_optional.cpp index 42ab7199..99d8a312 100644 --- a/test/test_optional.cpp +++ b/test/test_optional.cpp @@ -1034,5 +1034,5 @@ namespace CHECK_EQUAL(1, (*opt3)[0]); CHECK_EQUAL(20, (*opt3)[1]); } - }; + } } diff --git a/test/test_overload.cpp b/test/test_overload.cpp index 298c8c32..ba14ac1c 100644 --- a/test/test_overload.cpp +++ b/test/test_overload.cpp @@ -162,7 +162,7 @@ namespace CHECK(result.bd == false); CHECK(result.bs == true); } - }; + } } #endif diff --git a/test/test_parameter_pack.cpp b/test/test_parameter_pack.cpp index 83aa08d6..ce5a15c2 100644 --- a/test/test_parameter_pack.cpp +++ b/test/test_parameter_pack.cpp @@ -87,5 +87,5 @@ namespace // Static assert //CHECK((std::is_same_v>)); } - }; + } } diff --git a/test/test_parameter_type.cpp b/test/test_parameter_type.cpp index 3075f3cc..5a45131f 100644 --- a/test/test_parameter_type.cpp +++ b/test/test_parameter_type.cpp @@ -86,5 +86,5 @@ namespace b = !etl::is_reference::type>::value; CHECK(b); } - }; + } } diff --git a/test/test_parity_checksum.cpp b/test/test_parity_checksum.cpp index 74ac46c3..f4050fbf 100644 --- a/test/test_parity_checksum.cpp +++ b/test/test_parity_checksum.cpp @@ -142,6 +142,6 @@ namespace CHECK_EQUAL(hash1, hash2); CHECK_EQUAL(hash1, hash3); } - }; + } } diff --git a/test/test_pearson.cpp b/test/test_pearson.cpp index 06cddab7..2327948f 100644 --- a/test/test_pearson.cpp +++ b/test/test_pearson.cpp @@ -174,6 +174,6 @@ namespace hash_t hash3 = etl::pearson(data3.rbegin(), data3.rend()); CHECK(hash1 == hash3); } - }; + } } diff --git a/test/test_pool.cpp b/test/test_pool.cpp index df9b088c..2df96149 100644 --- a/test/test_pool.cpp +++ b/test/test_pool.cpp @@ -415,9 +415,9 @@ namespace etl::generic_pool pool; - uint8_t* p1 = nullptr; - uint32_t* p2 = nullptr; - double* p3 = nullptr; + uint8_t* p1 = nullptr; + uint32_t* p2 = nullptr; + double* p3 = nullptr; Test_Data* p4 = nullptr; (void)p1; @@ -430,430 +430,430 @@ namespace CHECK_NO_THROW(p3 = pool.allocate()); CHECK_NO_THROW(p4 = pool.allocate()); } - }; - //************************************************************************* - TEST(test_create_destroy) - { - etl::pool pool0; - etl::pool pool1; - etl::pool pool2; - etl::pool pool3; - etl::pool pool4; - - D0* p0 = pool0.create(); - D1* p1 = pool1.create("1"); - D2* p2 = pool2.create("1", "2"); - D3* p3 = pool3.create("1", "2", "3"); - D4* p4 = pool4.create("1", "2", "3", "4"); - - CHECK_EQUAL(pool0.max_size() - 1, pool0.available()); - CHECK_EQUAL(1U, pool0.size()); - - CHECK_EQUAL(pool1.max_size() - 1, pool1.available()); - CHECK_EQUAL(1U, pool1.size()); - - CHECK_EQUAL(pool2.max_size() - 1, pool2.available()); - CHECK_EQUAL(1U, pool2.size()); - - CHECK_EQUAL(pool3.max_size() - 1, pool3.available()); - CHECK_EQUAL(1U, pool3.size()); - - CHECK_EQUAL(pool4.max_size() - 1, pool4.available()); - CHECK_EQUAL(1U, pool4.size()); - - CHECK_EQUAL(D0(), *p0); - CHECK_EQUAL(D1("1"), *p1); - CHECK_EQUAL(D2("1", "2"), *p2); - CHECK_EQUAL(D3("1", "2", "3"), *p3); - CHECK_EQUAL(D4("1", "2", "3", "4"), *p4); - - pool0.destroy(p0); - pool1.destroy(p1); - pool2.destroy(p2); - pool3.destroy(p3); - pool4.destroy(p4); - - CHECK_EQUAL(pool0.max_size(), pool0.available()); - CHECK_EQUAL(0U, pool0.size()); - - CHECK_EQUAL(pool1.max_size(), pool1.available()); - CHECK_EQUAL(0U, pool1.size()); - - CHECK_EQUAL(pool2.max_size(), pool2.available()); - CHECK_EQUAL(0U, pool2.size()); - - CHECK_EQUAL(pool3.max_size(), pool3.available()); - CHECK_EQUAL(0U, pool3.size()); - - CHECK_EQUAL(pool4.max_size(), pool4.available()); - CHECK_EQUAL(0U, pool4.size()); - } - - //************************************************************************* - TEST(test_allocate_release_non_class) - { - etl::pool pool; - - int* i = pool.allocate(); - pool.release(i); - } - - //************************************************************************* - TEST(test_issue_406_pool_of_c_array) - { - using elem_type = uint8_t[10]; - - etl::pool memPool{}; - - CHECK_EQUAL(3, memPool.available()); - CHECK_EQUAL(0, memPool.size()); - - elem_type* memory = memPool.allocate(); - - CHECK_EQUAL(2, memPool.available()); - CHECK_EQUAL(1, memPool.size()); - - memPool.release(memory); - - CHECK_EQUAL(3, memPool.available()); - CHECK_EQUAL(0, memPool.size()); - } - - //************************************************************************* - TEST(test_iterators) - { - etl::pool pool0; - - etl::ipool::iterator begin = pool0.begin(); - etl::ipool::iterator end = pool0.end(); - - CHECK(begin == end); - CHECK(!(begin != end)); - CHECK_EQUAL(etl::distance(begin, end), 0); - - int* a = pool0.allocate(); - *a = 1; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 1); - - int* b = pool0.allocate(); - *b = 2; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); - - // post increment - for (auto i = pool0.begin(); i != pool0.end(); i++) + //************************************************************************* + TEST(test_create_destroy) { - CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); + etl::pool pool0; + etl::pool pool1; + etl::pool pool2; + etl::pool pool3; + etl::pool pool4; + + D0* p0 = pool0.create(); + D1* p1 = pool1.create("1"); + D2* p2 = pool2.create("1", "2"); + D3* p3 = pool3.create("1", "2", "3"); + D4* p4 = pool4.create("1", "2", "3", "4"); + + CHECK_EQUAL(pool0.max_size() - 1, pool0.available()); + CHECK_EQUAL(1U, pool0.size()); + + CHECK_EQUAL(pool1.max_size() - 1, pool1.available()); + CHECK_EQUAL(1U, pool1.size()); + + CHECK_EQUAL(pool2.max_size() - 1, pool2.available()); + CHECK_EQUAL(1U, pool2.size()); + + CHECK_EQUAL(pool3.max_size() - 1, pool3.available()); + CHECK_EQUAL(1U, pool3.size()); + + CHECK_EQUAL(pool4.max_size() - 1, pool4.available()); + CHECK_EQUAL(1U, pool4.size()); + + CHECK_EQUAL(D0(), *p0); + CHECK_EQUAL(D1("1"), *p1); + CHECK_EQUAL(D2("1", "2"), *p2); + CHECK_EQUAL(D3("1", "2", "3"), *p3); + CHECK_EQUAL(D4("1", "2", "3", "4"), *p4); + + pool0.destroy(p0); + pool1.destroy(p1); + pool2.destroy(p2); + pool3.destroy(p3); + pool4.destroy(p4); + + CHECK_EQUAL(pool0.max_size(), pool0.available()); + CHECK_EQUAL(0U, pool0.size()); + + CHECK_EQUAL(pool1.max_size(), pool1.available()); + CHECK_EQUAL(0U, pool1.size()); + + CHECK_EQUAL(pool2.max_size(), pool2.available()); + CHECK_EQUAL(0U, pool2.size()); + + CHECK_EQUAL(pool3.max_size(), pool3.available()); + CHECK_EQUAL(0U, pool3.size()); + + CHECK_EQUAL(pool4.max_size(), pool4.available()); + CHECK_EQUAL(0U, pool4.size()); } - // pre increment - for (auto i = pool0.begin(); i != pool0.end(); ++i) + //************************************************************************* + TEST(test_allocate_release_non_class) { - CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); + etl::pool pool; + + int* i = pool.allocate(); + pool.release(i); } - int* c = pool0.allocate(); - *c = 3; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); - - pool0.release(b); - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); - - int* d = pool0.allocate(); - *d = 4; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); - - b = pool0.allocate(); - *b = 2; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 4); - - // post increment - for (auto i = pool0.begin(); i != pool0.end(); i++) + //************************************************************************* + TEST(test_issue_406_pool_of_c_array) { - CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); + using elem_type = uint8_t[10]; + + etl::pool memPool{}; + + CHECK_EQUAL(3, memPool.available()); + CHECK_EQUAL(0, memPool.size()); + + elem_type* memory = memPool.allocate(); + + CHECK_EQUAL(2, memPool.available()); + CHECK_EQUAL(1, memPool.size()); + + memPool.release(memory); + + CHECK_EQUAL(3, memPool.available()); + CHECK_EQUAL(0, memPool.size()); } - // pre increment - for (auto i = pool0.begin(); i != pool0.end(); ++i) + //************************************************************************* + TEST(test_iterators) { - CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); - } + etl::pool pool0; - pool0.release(b); + etl::ipool::iterator begin = pool0.begin(); + etl::ipool::iterator end = pool0.end(); - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); + CHECK(begin == end); + CHECK(!(begin != end)); + CHECK_EQUAL(etl::distance(begin, end), 0); - pool0.release(a); + int* a = pool0.allocate(); + *a = 1; - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 1); - pool0.release(d); + int* b = pool0.allocate(); + *b = 2; - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 1); - - auto& v = begin.get(); - v = 1; - - pool0.release(c); - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin == end); - CHECK(!(begin != end)); - CHECK_EQUAL(etl::distance(begin, end), 0); - } - - //************************************************************************* - TEST(test_const_iterators) - { - etl::pool pool0; - - etl::ipool::const_iterator begin = pool0.begin(); - etl::ipool::const_iterator end = pool0.end(); - - CHECK(begin == end); - CHECK(!(begin != end)); - CHECK_EQUAL(etl::distance(begin, end), 0); - - int* a = pool0.allocate(); - *a = 1; - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 1); - - int* b = pool0.allocate(); - *b = 2; - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); - - // post increment - for (auto i = pool0.begin(); i != pool0.end(); i++) - { - CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); - } - - // pre increment - for (auto i = pool0.begin(); i != pool0.end(); ++i) - { - CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); - } - - int* c = pool0.allocate(); - *c = 3; - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); - - pool0.release(b); - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); - - int* d = pool0.allocate(); - *d = 4; - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); - - b = pool0.allocate(); - *b = 2; - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 4); - - // post increment - for (auto i = pool0.begin(); i != pool0.end(); i++) - { - CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); - } - - // pre increment - for (auto i = pool0.cbegin(); i != pool0.cend(); ++i) - { - CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); - } - - pool0.release(b); - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 3); - - pool0.release(a); - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 2); - - pool0.release(d); - - begin = pool0.begin(); - end = pool0.end(); - CHECK(begin != end); - CHECK(!(begin == end)); - CHECK_EQUAL(etl::distance(begin, end), 1); - - const auto& v = begin.get(); - CHECK(v != 0); - - pool0.release(c); - - begin = pool0.cbegin(); - end = pool0.cend(); - CHECK(begin == end); - CHECK(!(begin != end)); - CHECK_EQUAL(etl::distance(begin, end), 0); - } - - //************************************************************************* - TEST(test_releaser_functor_with_unique_ptr) - { - etl::pool pool; - auto pool_deleter = [&pool](S* ptr) { pool.release(ptr); }; - using Unique = etl::unique_ptr; - - S::instance_count = 0; - - CHECK_EQUAL(10, pool.available()); - - { - S* ps; - - ps = pool.allocate(); - ::new(ps) S(1, 2); - Unique us1(ps, pool_deleter); - CHECK_EQUAL(1, S::instance_count); - CHECK_EQUAL(1, us1->a); - CHECK_EQUAL(2, us1->b); - CHECK_EQUAL(9, pool.available()); + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + // post increment + for (auto i = pool0.begin(); i != pool0.end(); i++) { - ps = pool.allocate(); - ::new(ps) S(3, 4); - Unique us2(ps, pool_deleter); - CHECK_EQUAL(2, S::instance_count); - CHECK_EQUAL(3, us2->a); - CHECK_EQUAL(4, us2->b); - CHECK_EQUAL(8, pool.available()); - us2->~S(); + CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); } - ps = pool.allocate(); - ::new(ps) S(5, 6); - Unique us3(ps, pool_deleter); - CHECK_EQUAL(2, S::instance_count); - CHECK_EQUAL(5, us3->a); - CHECK_EQUAL(6, us3->b); - CHECK_EQUAL(8, pool.available()); - us1->~S(); - us3->~S(); + // pre increment + for (auto i = pool0.begin(); i != pool0.end(); ++i) + { + CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); + } + + int* c = pool0.allocate(); + *c = 3; + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + pool0.release(b); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + + int* d = pool0.allocate(); + *d = 4; + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + b = pool0.allocate(); + *b = 2; + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 4); + + // post increment + for (auto i = pool0.begin(); i != pool0.end(); i++) + { + CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); + } + + // pre increment + for (auto i = pool0.begin(); i != pool0.end(); ++i) + { + CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); + } + + pool0.release(b); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + pool0.release(a); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + + pool0.release(d); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 1); + + auto& v = begin.get(); + v = 1; + + pool0.release(c); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin == end); + CHECK(!(begin != end)); + CHECK_EQUAL(etl::distance(begin, end), 0); } - CHECK_EQUAL(0, S::instance_count); - CHECK_EQUAL(10, pool.available()); - } - - //************************************************************************* - TEST(test_destroyer_functor_with_unique_ptr) - { - etl::pool pool; - auto pool_deleter = [&pool](S* ptr) { pool.destroy(ptr); }; - using Unique = etl::unique_ptr; - - S::instance_count = 0; - - CHECK_EQUAL(10, pool.available()); - + //************************************************************************* + TEST(test_const_iterators) { - Unique us1(pool.create(1, 2), pool_deleter); - CHECK_EQUAL(1, S::instance_count); - CHECK_EQUAL(1, us1->a); - CHECK_EQUAL(2, us1->b); - CHECK_EQUAL(9, pool.available()); + etl::pool pool0; + + etl::ipool::const_iterator begin = pool0.begin(); + etl::ipool::const_iterator end = pool0.end(); + + CHECK(begin == end); + CHECK(!(begin != end)); + CHECK_EQUAL(etl::distance(begin, end), 0); + + int* a = pool0.allocate(); + *a = 1; + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 1); + + int* b = pool0.allocate(); + *b = 2; + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + + // post increment + for (auto i = pool0.begin(); i != pool0.end(); i++) + { + CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); + } + + // pre increment + for (auto i = pool0.begin(); i != pool0.end(); ++i) + { + CHECK(*reinterpret_cast(*i) == 1 || *reinterpret_cast(*i) == 2); + } + + int* c = pool0.allocate(); + *c = 3; + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + pool0.release(b); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + + int* d = pool0.allocate(); + *d = 4; + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + b = pool0.allocate(); + *b = 2; + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 4); + + // post increment + for (auto i = pool0.begin(); i != pool0.end(); i++) + { + CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); + } + + // pre increment + for (auto i = pool0.cbegin(); i != pool0.cend(); ++i) + { + CHECK(*reinterpret_cast(*i) >= 1 && *reinterpret_cast(*i) <= 4); + } + + pool0.release(b); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 3); + + pool0.release(a); + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 2); + + pool0.release(d); + + begin = pool0.begin(); + end = pool0.end(); + CHECK(begin != end); + CHECK(!(begin == end)); + CHECK_EQUAL(etl::distance(begin, end), 1); + + const auto& v = begin.get(); + CHECK(v != 0); + + pool0.release(c); + + begin = pool0.cbegin(); + end = pool0.cend(); + CHECK(begin == end); + CHECK(!(begin != end)); + CHECK_EQUAL(etl::distance(begin, end), 0); + } + + //************************************************************************* + TEST(test_releaser_functor_with_unique_ptr) + { + etl::pool pool; + auto pool_deleter = [&pool](S* ptr) { pool.release(ptr); }; + using Unique = etl::unique_ptr; + + S::instance_count = 0; + + CHECK_EQUAL(10, pool.available()); { - Unique us2(pool.create(3, 4), pool_deleter); + S* ps; + + ps = pool.allocate(); + ::new(ps) S(1, 2); + Unique us1(ps, pool_deleter); + CHECK_EQUAL(1, S::instance_count); + CHECK_EQUAL(1, us1->a); + CHECK_EQUAL(2, us1->b); + CHECK_EQUAL(9, pool.available()); + + { + ps = pool.allocate(); + ::new(ps) S(3, 4); + Unique us2(ps, pool_deleter); + CHECK_EQUAL(2, S::instance_count); + CHECK_EQUAL(3, us2->a); + CHECK_EQUAL(4, us2->b); + CHECK_EQUAL(8, pool.available()); + us2->~S(); + } + + ps = pool.allocate(); + ::new(ps) S(5, 6); + Unique us3(ps, pool_deleter); CHECK_EQUAL(2, S::instance_count); - CHECK_EQUAL(3, us2->a); - CHECK_EQUAL(4, us2->b); + CHECK_EQUAL(5, us3->a); + CHECK_EQUAL(6, us3->b); + CHECK_EQUAL(8, pool.available()); + us1->~S(); + us3->~S(); + } + + CHECK_EQUAL(0, S::instance_count); + CHECK_EQUAL(10, pool.available()); + } + + //************************************************************************* + TEST(test_destroyer_functor_with_unique_ptr) + { + etl::pool pool; + auto pool_deleter = [&pool](S* ptr) { pool.destroy(ptr); }; + using Unique = etl::unique_ptr; + + S::instance_count = 0; + + CHECK_EQUAL(10, pool.available()); + + { + Unique us1(pool.create(1, 2), pool_deleter); + CHECK_EQUAL(1, S::instance_count); + CHECK_EQUAL(1, us1->a); + CHECK_EQUAL(2, us1->b); + CHECK_EQUAL(9, pool.available()); + + { + Unique us2(pool.create(3, 4), pool_deleter); + CHECK_EQUAL(2, S::instance_count); + CHECK_EQUAL(3, us2->a); + CHECK_EQUAL(4, us2->b); + CHECK_EQUAL(8, pool.available()); + } + + CHECK_EQUAL(1, S::instance_count); + + Unique us3(pool.create(5, 6), pool_deleter); + CHECK_EQUAL(2, S::instance_count); + CHECK_EQUAL(5, us3->a); + CHECK_EQUAL(6, us3->b); CHECK_EQUAL(8, pool.available()); } - CHECK_EQUAL(1, S::instance_count); - - Unique us3(pool.create(5, 6), pool_deleter); - CHECK_EQUAL(2, S::instance_count); - CHECK_EQUAL(5, us3->a); - CHECK_EQUAL(6, us3->b); - CHECK_EQUAL(8, pool.available()); + CHECK_EQUAL(0, S::instance_count); + CHECK_EQUAL(10, pool.available()); } - - CHECK_EQUAL(0, S::instance_count); - CHECK_EQUAL(10, pool.available()); } } diff --git a/test/test_priority_queue.cpp b/test/test_priority_queue.cpp index c1f2d072..8d2b5067 100644 --- a/test/test_priority_queue.cpp +++ b/test/test_priority_queue.cpp @@ -650,5 +650,5 @@ namespace priority_queue2.pop(); } } - }; + } } diff --git a/test/test_pseudo_moving_average.cpp b/test/test_pseudo_moving_average.cpp index b640762b..a9b26f0e 100644 --- a/test/test_pseudo_moving_average.cpp +++ b/test/test_pseudo_moving_average.cpp @@ -344,5 +344,5 @@ namespace CHECK_CLOSE(2.82, cma.value(), 0.01); } - }; + } } diff --git a/test/test_quantize.cpp b/test/test_quantize.cpp index 1501d4c1..6c9802de 100644 --- a/test/test_quantize.cpp +++ b/test/test_quantize.cpp @@ -119,5 +119,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2a.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_queue.cpp b/test/test_queue.cpp index 71d033f1..1f2a04cf 100644 --- a/test/test_queue.cpp +++ b/test/test_queue.cpp @@ -575,5 +575,5 @@ namespace CHECK_EQUAL(4, queue.front()); queue.pop(); } - }; + } } diff --git a/test/test_queue_lockable.cpp b/test/test_queue_lockable.cpp index 2bebeb09..893e5d2a 100644 --- a/test/test_queue_lockable.cpp +++ b/test/test_queue_lockable.cpp @@ -754,5 +754,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_queue_lockable_small.cpp b/test/test_queue_lockable_small.cpp index c1bf69b2..bc123464 100644 --- a/test/test_queue_lockable_small.cpp +++ b/test/test_queue_lockable_small.cpp @@ -757,5 +757,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_queue_memory_model_small.cpp b/test/test_queue_memory_model_small.cpp index d640cd8a..14aab550 100644 --- a/test/test_queue_memory_model_small.cpp +++ b/test/test_queue_memory_model_small.cpp @@ -550,5 +550,5 @@ namespace CHECK_EQUAL(4, queue.front()); queue.pop(); } - }; + } } diff --git a/test/test_queue_mpmc_mutex.cpp b/test/test_queue_mpmc_mutex.cpp index cdb6e6c1..96c9c4e0 100644 --- a/test/test_queue_mpmc_mutex.cpp +++ b/test/test_queue_mpmc_mutex.cpp @@ -508,10 +508,10 @@ namespace TEST(queue_threads) { push1.reserve(LENGTH / 2); - push2.reserve(LENGTH / 2);; + push2.reserve(LENGTH / 2); - pop1.reserve(LENGTH / 2);; - pop2.reserve(LENGTH / 2);; + pop1.reserve(LENGTH / 2); + pop2.reserve(LENGTH / 2); start = false; @@ -550,7 +550,7 @@ namespace } } #endif - }; + } } #endif diff --git a/test/test_queue_mpmc_mutex_small.cpp b/test/test_queue_mpmc_mutex_small.cpp index 7abf00fc..094cf7b5 100644 --- a/test/test_queue_mpmc_mutex_small.cpp +++ b/test/test_queue_mpmc_mutex_small.cpp @@ -533,10 +533,10 @@ namespace TEST(queue_threads) { push1.reserve(LENGTH / 2); - push2.reserve(LENGTH / 2);; + push2.reserve(LENGTH / 2); - pop1.reserve(LENGTH / 2);; - pop2.reserve(LENGTH / 2);; + pop1.reserve(LENGTH / 2); + pop2.reserve(LENGTH / 2); start = false; @@ -575,7 +575,7 @@ namespace } } #endif - }; + } } #endif diff --git a/test/test_queue_spsc_atomic.cpp b/test/test_queue_spsc_atomic.cpp index 232249e1..c69c2d2c 100644 --- a/test/test_queue_spsc_atomic.cpp +++ b/test/test_queue_spsc_atomic.cpp @@ -456,7 +456,7 @@ namespace } } #endif - }; + } } #endif diff --git a/test/test_queue_spsc_atomic_small.cpp b/test/test_queue_spsc_atomic_small.cpp index f1ed6fbc..3a9edde0 100644 --- a/test/test_queue_spsc_atomic_small.cpp +++ b/test/test_queue_spsc_atomic_small.cpp @@ -474,7 +474,7 @@ namespace } } #endif - }; + } } #endif diff --git a/test/test_queue_spsc_isr.cpp b/test/test_queue_spsc_isr.cpp index 2d80f4db..3e26aeaf 100644 --- a/test/test_queue_spsc_isr.cpp +++ b/test/test_queue_spsc_isr.cpp @@ -712,5 +712,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_queue_spsc_isr_small.cpp b/test/test_queue_spsc_isr_small.cpp index b55f3cd5..79765f4e 100644 --- a/test/test_queue_spsc_isr_small.cpp +++ b/test/test_queue_spsc_isr_small.cpp @@ -730,5 +730,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_queue_spsc_locked.cpp b/test/test_queue_spsc_locked.cpp index 993e5e78..be60cbab 100644 --- a/test/test_queue_spsc_locked.cpp +++ b/test/test_queue_spsc_locked.cpp @@ -720,5 +720,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_queue_spsc_locked_small.cpp b/test/test_queue_spsc_locked_small.cpp index 644f0a81..edb93fc0 100644 --- a/test/test_queue_spsc_locked_small.cpp +++ b/test/test_queue_spsc_locked_small.cpp @@ -737,5 +737,5 @@ namespace } } #endif - }; + } } diff --git a/test/test_random.cpp b/test/test_random.cpp index 615c5b82..b479d3e8 100644 --- a/test/test_random.cpp +++ b/test/test_random.cpp @@ -411,6 +411,5 @@ namespace CHECK(n <= high); } } - - }; + } } diff --git a/test/test_ratio.cpp b/test/test_ratio.cpp index 76f67fda..cd71a410 100644 --- a/test/test_ratio.cpp +++ b/test/test_ratio.cpp @@ -225,6 +225,5 @@ namespace CHECK((etl::ratio_greater_equal_v)); #endif } - }; - + } } diff --git a/test/test_reference_flat_map.cpp b/test/test_reference_flat_map.cpp index f16bf664..47df8185 100644 --- a/test/test_reference_flat_map.cpp +++ b/test/test_reference_flat_map.cpp @@ -976,5 +976,5 @@ namespace CHECK(initial1 != different); } - }; + } } diff --git a/test/test_reference_flat_multimap.cpp b/test/test_reference_flat_multimap.cpp index 2c68e161..ef04031c 100644 --- a/test/test_reference_flat_multimap.cpp +++ b/test/test_reference_flat_multimap.cpp @@ -918,5 +918,5 @@ namespace CHECK_EQUAL(compare_data.count(4), data.count(Key(4))); CHECK_EQUAL(compare_data.count(5), data.count(Key(5))); } - }; + } } diff --git a/test/test_reference_flat_multiset.cpp b/test/test_reference_flat_multiset.cpp index 52f55c94..7927776a 100644 --- a/test/test_reference_flat_multiset.cpp +++ b/test/test_reference_flat_multiset.cpp @@ -837,5 +837,5 @@ namespace CHECK_EQUAL(compare_data.count(N3), data.count(N3)); CHECK_EQUAL(compare_data.count(N4), data.count(N4)); } - }; + } } diff --git a/test/test_reference_flat_set.cpp b/test/test_reference_flat_set.cpp index be0834a3..4a5ea5a3 100644 --- a/test/test_reference_flat_set.cpp +++ b/test/test_reference_flat_set.cpp @@ -836,5 +836,5 @@ namespace CHECK(initial1 != different); } - }; + } } diff --git a/test/test_rescale.cpp b/test/test_rescale.cpp index 9f65dfd5..d57a2403 100644 --- a/test/test_rescale.cpp +++ b/test/test_rescale.cpp @@ -93,5 +93,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_result.cpp b/test/test_result.cpp index e2af3556..90a38109 100644 --- a/test/test_result.cpp +++ b/test/test_result.cpp @@ -370,5 +370,5 @@ namespace CHECK(output.v != input.v); CHECK(output2.v == input.v); } - }; + } } diff --git a/test/test_rms.cpp b/test/test_rms.cpp index 39ae6753..2dfb803f 100644 --- a/test/test_rms.cpp +++ b/test/test_rms.cpp @@ -66,5 +66,5 @@ namespace CHECK_CLOSE(5.21, result, 0.05); } - }; + } } diff --git a/test/test_rounded_integral_division.cpp b/test/test_rounded_integral_division.cpp index dc91390b..608d39df 100644 --- a/test/test_rounded_integral_division.cpp +++ b/test/test_rounded_integral_division.cpp @@ -891,5 +891,5 @@ namespace CHECK_EQUAL(std::numeric_limits::max(), etl::divide_round_half_odd(std::numeric_limits::max(), uint32_t(1))); CHECK_EQUAL(uint32_t(0U), etl::divide_round_half_odd(uint32_t(1), std::numeric_limits::max())); } - }; + } } diff --git a/test/test_scaled_rounding.cpp b/test/test_scaled_rounding.cpp index 518eada2..39aa4432 100644 --- a/test/test_scaled_rounding.cpp +++ b/test/test_scaled_rounding.cpp @@ -1843,5 +1843,5 @@ namespace CHECK_EQUAL(10, round_zero); } #endif - }; + } } diff --git a/test/test_set.cpp b/test/test_set.cpp index 0865eff8..852b6866 100644 --- a/test/test_set.cpp +++ b/test/test_set.cpp @@ -1468,5 +1468,5 @@ namespace CHECK(!data.contains(99)); CHECK(!data.contains(Key(99))); } - }; + } } diff --git a/test/test_smallest.cpp b/test/test_smallest.cpp index e7aaa290..68b3ce12 100644 --- a/test/test_smallest.cpp +++ b/test/test_smallest.cpp @@ -456,5 +456,5 @@ namespace type = etl::is_same>::value; CHECK(type); } - }; + } } diff --git a/test/test_span_dynamic_extent.cpp b/test/test_span_dynamic_extent.cpp index 1a11fee5..e9045504 100644 --- a/test/test_span_dynamic_extent.cpp +++ b/test/test_span_dynamic_extent.cpp @@ -1539,5 +1539,5 @@ namespace } #include "etl/private/diagnostic_pop.h" - }; + } } diff --git a/test/test_span_fixed_extent.cpp b/test/test_span_fixed_extent.cpp index 70d4350d..137bd9b8 100644 --- a/test/test_span_fixed_extent.cpp +++ b/test/test_span_fixed_extent.cpp @@ -1305,5 +1305,5 @@ namespace } #include "etl/private/diagnostic_pop.h" - }; + } } diff --git a/test/test_stack.cpp b/test/test_stack.cpp index 81d35b46..cd05ddf2 100644 --- a/test/test_stack.cpp +++ b/test/test_stack.cpp @@ -561,5 +561,5 @@ namespace stack.pop_into(i); CHECK_EQUAL(4, i); } - }; + } } diff --git a/test/test_standard_deviation.cpp b/test/test_standard_deviation.cpp index d5e52d98..ea9247dd 100644 --- a/test/test_standard_deviation.cpp +++ b/test/test_standard_deviation.cpp @@ -160,5 +160,5 @@ namespace variance_result = standard_deviation.get_variance(); CHECK_CLOSE(9.17, variance_result, 0.1); } - }; + } } diff --git a/test/test_state_chart.cpp b/test/test_state_chart.cpp index 53454bf6..8a005eba 100644 --- a/test/test_state_chart.cpp +++ b/test/test_state_chart.cpp @@ -599,5 +599,5 @@ namespace motorControl.process_event(EventId::ABORT); CHECK_EQUAL(StateId::IDLE, int(motorControl.get_state_id())); } - }; + } } diff --git a/test/test_state_chart_compile_time.cpp b/test/test_state_chart_compile_time.cpp index f3397834..a12c2a1a 100644 --- a/test/test_state_chart_compile_time.cpp +++ b/test/test_state_chart_compile_time.cpp @@ -608,5 +608,5 @@ namespace motorControlStateChart.process_event(EventId::ABORT); CHECK_EQUAL(StateId::IDLE, int(motorControlStateChart.get_state_id())); } - }; + } } diff --git a/test/test_state_chart_compile_time_with_data_parameter.cpp b/test/test_state_chart_compile_time_with_data_parameter.cpp index 55311a28..407d8ef4 100644 --- a/test/test_state_chart_compile_time_with_data_parameter.cpp +++ b/test/test_state_chart_compile_time_with_data_parameter.cpp @@ -504,5 +504,5 @@ namespace motorControlStateChart.process_event(EventId::ABORT, 5); CHECK_EQUAL(StateId::IDLE, int(motorControlStateChart.get_state_id())); } - }; + } } diff --git a/test/test_state_chart_with_data_parameter.cpp b/test/test_state_chart_with_data_parameter.cpp index 80377a60..23b75b15 100644 --- a/test/test_state_chart_with_data_parameter.cpp +++ b/test/test_state_chart_with_data_parameter.cpp @@ -495,5 +495,5 @@ namespace motorControl.process_event(EventId::ABORT, 5); CHECK_EQUAL(StateId::IDLE, int(motorControl.get_state_id())); } - }; + } } diff --git a/test/test_state_chart_with_rvalue_data_parameter.cpp b/test/test_state_chart_with_rvalue_data_parameter.cpp index 17d8ac4b..97307d33 100644 --- a/test/test_state_chart_with_rvalue_data_parameter.cpp +++ b/test/test_state_chart_with_rvalue_data_parameter.cpp @@ -511,5 +511,5 @@ namespace motorControl.process_event(EventId::ABORT, Data(5)); CHECK_EQUAL(StateId::IDLE, int(motorControl.get_state_id())); } - }; + } } diff --git a/test/test_string_char.cpp b/test/test_string_char.cpp index 6cf70b28..faa28d7e 100644 --- a/test/test_string_char.cpp +++ b/test/test_string_char.cpp @@ -5486,5 +5486,5 @@ namespace CHECK(text1 == sstream_view); } #endif - }; + } } diff --git a/test/test_string_char_external_buffer.cpp b/test/test_string_char_external_buffer.cpp index e644f578..15790f43 100644 --- a/test/test_string_char_external_buffer.cpp +++ b/test/test_string_char_external_buffer.cpp @@ -5787,5 +5787,5 @@ namespace CHECK(text1 == sstream_view); } #endif - }; + } } diff --git a/test/test_string_stream.cpp b/test/test_string_stream.cpp index e765950d..44414771 100644 --- a/test/test_string_stream.cpp +++ b/test/test_string_stream.cpp @@ -326,6 +326,6 @@ namespace CHECK_EQUAL(String(STR("Hello")), istr); } - }; + } } diff --git a/test/test_string_stream_u16.cpp b/test/test_string_stream_u16.cpp index 9a48cc76..043c927f 100644 --- a/test/test_string_stream_u16.cpp +++ b/test/test_string_stream_u16.cpp @@ -286,6 +286,6 @@ namespace CHECK_EQUAL(String(STR("Hello")), istr); } - }; + } } diff --git a/test/test_string_stream_u32.cpp b/test/test_string_stream_u32.cpp index a2213e45..f630b6f6 100644 --- a/test/test_string_stream_u32.cpp +++ b/test/test_string_stream_u32.cpp @@ -286,6 +286,6 @@ namespace CHECK_EQUAL(String(STR("Hello")), istr); } - }; + } } diff --git a/test/test_string_stream_u8.cpp b/test/test_string_stream_u8.cpp index 10b08976..31b86275 100644 --- a/test/test_string_stream_u8.cpp +++ b/test/test_string_stream_u8.cpp @@ -289,7 +289,7 @@ namespace CHECK_EQUAL(String(STR("Hello")), istr); } - }; + } } #endif diff --git a/test/test_string_stream_wchar_t.cpp b/test/test_string_stream_wchar_t.cpp index f594a39a..9f2dae9d 100644 --- a/test/test_string_stream_wchar_t.cpp +++ b/test/test_string_stream_wchar_t.cpp @@ -287,6 +287,6 @@ namespace CHECK_EQUAL(String(STR("Hello")), istr); } - }; + } } diff --git a/test/test_string_u16.cpp b/test/test_string_u16.cpp index a569d269..5cf79d06 100644 --- a/test/test_string_u16.cpp +++ b/test/test_string_u16.cpp @@ -5540,5 +5540,5 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } diff --git a/test/test_string_u16_external_buffer.cpp b/test/test_string_u16_external_buffer.cpp index 41e60750..b22f43dd 100644 --- a/test/test_string_u16_external_buffer.cpp +++ b/test/test_string_u16_external_buffer.cpp @@ -5868,5 +5868,5 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } diff --git a/test/test_string_u32.cpp b/test/test_string_u32.cpp index 5201371e..d7913b75 100644 --- a/test/test_string_u32.cpp +++ b/test/test_string_u32.cpp @@ -5540,5 +5540,5 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } diff --git a/test/test_string_u32_external_buffer.cpp b/test/test_string_u32_external_buffer.cpp index f02a460d..c0b8150b 100644 --- a/test/test_string_u32_external_buffer.cpp +++ b/test/test_string_u32_external_buffer.cpp @@ -5868,5 +5868,5 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } diff --git a/test/test_string_u8.cpp b/test/test_string_u8.cpp index 65eeb767..98d68d01 100644 --- a/test/test_string_u8.cpp +++ b/test/test_string_u8.cpp @@ -5485,6 +5485,6 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } #endif \ No newline at end of file diff --git a/test/test_string_u8_external_buffer.cpp b/test/test_string_u8_external_buffer.cpp index 6f4befa5..e161bc13 100644 --- a/test/test_string_u8_external_buffer.cpp +++ b/test/test_string_u8_external_buffer.cpp @@ -5787,7 +5787,7 @@ namespace #endif CHECK_EQUAL(text.max_size(), text.size()); } - }; + } } #endif \ No newline at end of file diff --git a/test/test_string_utilities.cpp b/test/test_string_utilities.cpp index 0bd4fb13..0f450da3 100644 --- a/test/test_string_utilities.cpp +++ b/test/test_string_utilities.cpp @@ -1863,5 +1863,5 @@ namespace CHECK_TRUE(result.truncated); CHECK_FALSE(result.terminated); } - }; + } } diff --git a/test/test_string_utilities_std.cpp b/test/test_string_utilities_std.cpp index bdc3fe72..ea8ad202 100644 --- a/test/test_string_utilities_std.cpp +++ b/test/test_string_utilities_std.cpp @@ -1614,7 +1614,7 @@ namespace CHECK(text == expected); } - }; + } } #endif diff --git a/test/test_string_utilities_std_u16.cpp b/test/test_string_utilities_std_u16.cpp index 20da6ee4..1487947f 100644 --- a/test/test_string_utilities_std_u16.cpp +++ b/test/test_string_utilities_std_u16.cpp @@ -1589,7 +1589,7 @@ namespace CHECK(textview.end() == itr); } - }; + } } #endif diff --git a/test/test_string_utilities_std_u32.cpp b/test/test_string_utilities_std_u32.cpp index fe0e68fa..5688cbcf 100644 --- a/test/test_string_utilities_std_u32.cpp +++ b/test/test_string_utilities_std_u32.cpp @@ -1587,7 +1587,7 @@ namespace CHECK(textview.end() == itr); } - }; + } } #endif diff --git a/test/test_string_utilities_std_u8.cpp b/test/test_string_utilities_std_u8.cpp index 7d762dba..87e2a60f 100644 --- a/test/test_string_utilities_std_u8.cpp +++ b/test/test_string_utilities_std_u8.cpp @@ -1589,7 +1589,7 @@ namespace CHECK(textview.end() == itr); } - }; + } } #endif diff --git a/test/test_string_utilities_std_wchar_t.cpp b/test/test_string_utilities_std_wchar_t.cpp index 994a35a7..fcd16321 100644 --- a/test/test_string_utilities_std_wchar_t.cpp +++ b/test/test_string_utilities_std_wchar_t.cpp @@ -1587,7 +1587,7 @@ namespace CHECK(textview.end() == itr); } - }; + } } #endif diff --git a/test/test_string_utilities_u16.cpp b/test/test_string_utilities_u16.cpp index 55674381..12417262 100644 --- a/test/test_string_utilities_u16.cpp +++ b/test/test_string_utilities_u16.cpp @@ -1632,5 +1632,5 @@ namespace CHECK(textview.end() == itr); } - }; + } } diff --git a/test/test_string_utilities_u32.cpp b/test/test_string_utilities_u32.cpp index 98280105..275267b7 100644 --- a/test/test_string_utilities_u32.cpp +++ b/test/test_string_utilities_u32.cpp @@ -1632,5 +1632,5 @@ namespace CHECK(textview.end() == itr); } - }; + } } diff --git a/test/test_string_utilities_u8.cpp b/test/test_string_utilities_u8.cpp index c5f0da76..9ae4d453 100644 --- a/test/test_string_utilities_u8.cpp +++ b/test/test_string_utilities_u8.cpp @@ -1635,7 +1635,7 @@ namespace CHECK(textview.end() == itr); } - }; + } } #endif diff --git a/test/test_string_utilities_wchar_t.cpp b/test/test_string_utilities_wchar_t.cpp index 8752a9fb..7666e54d 100644 --- a/test/test_string_utilities_wchar_t.cpp +++ b/test/test_string_utilities_wchar_t.cpp @@ -1632,5 +1632,5 @@ namespace CHECK(textview.end() == itr); } - }; + } } diff --git a/test/test_string_view.cpp b/test/test_string_view.cpp index 598f6332..a65b938b 100644 --- a/test/test_string_view.cpp +++ b/test/test_string_view.cpp @@ -1155,5 +1155,5 @@ namespace CHECK_TRUE(u32view == u32sstream_view); } #endif - }; + } } diff --git a/test/test_string_wchar_t.cpp b/test/test_string_wchar_t.cpp index 4ac88729..7e8b576e 100644 --- a/test/test_string_wchar_t.cpp +++ b/test/test_string_wchar_t.cpp @@ -5559,5 +5559,5 @@ namespace CHECK(text1 == sstream_view); } #endif - }; + } } diff --git a/test/test_string_wchar_t_external_buffer.cpp b/test/test_string_wchar_t_external_buffer.cpp index 6b1b5e08..7bc6ca8a 100644 --- a/test/test_string_wchar_t_external_buffer.cpp +++ b/test/test_string_wchar_t_external_buffer.cpp @@ -5890,5 +5890,5 @@ namespace CHECK(text1 == sstream_view); } #endif - }; + } } diff --git a/test/test_task_scheduler.cpp b/test/test_task_scheduler.cpp index 5d33f669..67c72ded 100644 --- a/test/test_task_scheduler.cpp +++ b/test/test_task_scheduler.cpp @@ -287,5 +287,5 @@ namespace CHECK(expected == common.workList); CHECK(common.watchdog_called); } - }; + } } diff --git a/test/test_threshold.cpp b/test/test_threshold.cpp index 47768028..b467d54f 100644 --- a/test/test_threshold.cpp +++ b/test/test_threshold.cpp @@ -133,5 +133,5 @@ namespace bool isEqual = std::equal(output2.begin(), output2.end(), result2b.begin(), Compare()); CHECK(isEqual); } - }; + } } diff --git a/test/test_to_string.cpp b/test/test_to_string.cpp index dfb2ea44..43888a67 100644 --- a/test/test_to_string.cpp +++ b/test/test_to_string.cpp @@ -662,6 +662,6 @@ namespace CHECK_EQUAL(etl::string<20>(STR("-124.0000")).c_str(), result_i.c_str()); CHECK_EQUAL(result_d.c_str(), result_i.c_str()); } - }; + } } diff --git a/test/test_to_u16string.cpp b/test/test_to_u16string.cpp index 5d964070..19d54efb 100644 --- a/test/test_to_u16string.cpp +++ b/test/test_to_u16string.cpp @@ -565,6 +565,6 @@ namespace CHECK(etl::u16string<20>(STR("-124.0000")) == result_i); CHECK(result_d == result_i); } - }; + } } diff --git a/test/test_to_u32string.cpp b/test/test_to_u32string.cpp index a5a75c82..27021f8a 100644 --- a/test/test_to_u32string.cpp +++ b/test/test_to_u32string.cpp @@ -570,6 +570,6 @@ namespace CHECK(etl::u32string<20>(STR("-124.0000")) == result_i); CHECK(result_d == result_i); } - }; + } } diff --git a/test/test_to_u8string.cpp b/test/test_to_u8string.cpp index c7bf6f80..d4376c36 100644 --- a/test/test_to_u8string.cpp +++ b/test/test_to_u8string.cpp @@ -567,7 +567,7 @@ namespace CHECK(etl::u8string<20>(STR("-124.0000")) == result_i); CHECK(result_d == result_i); } - }; + } } #endif diff --git a/test/test_to_wstring.cpp b/test/test_to_wstring.cpp index ca97b3b4..b785fec2 100644 --- a/test/test_to_wstring.cpp +++ b/test/test_to_wstring.cpp @@ -632,6 +632,6 @@ namespace CHECK(etl::wstring<20>(STR("-124.0000")) == result_i); CHECK(result_d == result_i); } - }; + } } diff --git a/test/test_type_def.cpp b/test/test_type_def.cpp index facb2ed8..fc984f7a 100644 --- a/test/test_type_def.cpp +++ b/test/test_type_def.cpp @@ -336,5 +336,5 @@ namespace CHECK_EQUAL(-3, value_minus.get()); } #endif - }; + } } diff --git a/test/test_type_list.cpp b/test/test_type_list.cpp index df37af51..cd53981c 100644 --- a/test/test_type_list.cpp +++ b/test/test_type_list.cpp @@ -261,6 +261,6 @@ namespace //CHECK_FALSE((etl::type_lists_are_convertible_v)); #endif } - }; + } #endif } diff --git a/test/test_type_lookup.cpp b/test/test_type_lookup.cpp index 68a6d7d3..01575cca 100644 --- a/test/test_type_lookup.cpp +++ b/test/test_type_lookup.cpp @@ -425,7 +425,7 @@ namespace CHECK((etl::is_same>::value)); } #endif - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_type_select.cpp b/test/test_type_select.cpp index 4cad3dff..1fe370ef 100644 --- a/test/test_type_select.cpp +++ b/test/test_type_select.cpp @@ -182,5 +182,5 @@ namespace CHECK(!(etl::is_same, typename Types16::select_t<15>>::value)); } #endif - }; + } } diff --git a/test/test_type_traits.cpp b/test/test_type_traits.cpp index 76d8b8cc..3083343b 100644 --- a/test/test_type_traits.cpp +++ b/test/test_type_traits.cpp @@ -70,7 +70,7 @@ namespace struct ToAny { ToAny() = default; - template ToAny(T){}; + template ToAny(T){} template operator T() { return T(); } }; @@ -976,693 +976,693 @@ namespace CHECK((etl::is_same::const_pointer>::value)); CHECK((etl::is_same::const_pointer_const>::value)); } - }; - //************************************************************************* - TEST(test_conditional_integral_constant) - { - int v1 = etl::conditional_integral_constant::value; - int v2 = etl::conditional_integral_constant::value; - - CHECK_EQUAL(1, v1); - CHECK_EQUAL(2, v2); - } - - //************************************************************************* - TEST(test_size_of) - { -#if ETL_USING_CPP17 - CHECK_EQUAL(1, etl::size_of_v); - CHECK_EQUAL(1, etl::size_of_v); - CHECK_EQUAL(2, etl::size_of_v); - CHECK_EQUAL(4, etl::size_of_v); - CHECK_EQUAL(20, etl::size_of_v); -#else - CHECK_EQUAL(1, etl::size_of::value); - CHECK_EQUAL(1, etl::size_of::value); - CHECK_EQUAL(2, etl::size_of::value); - CHECK_EQUAL(4, etl::size_of::value); - CHECK_EQUAL(20, etl::size_of::value); -#endif - } - - //************************************************************************* - TEST(test_is_convertible) - { -#if ETL_USING_CPP17 - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK((etl::is_convertible_v)); - CHECK(!(etl::is_convertible_v)); - CHECK(!(etl::is_convertible_v)); - CHECK(!(etl::is_convertible_v)); - CHECK(!(etl::is_convertible_v)); -#else - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK((etl::is_convertible::value)); - CHECK(!(etl::is_convertible::value)); - CHECK(!(etl::is_convertible::value)); - CHECK(!(etl::is_convertible::value)); - CHECK(!(etl::is_convertible::value)); -#endif - } - - //************************************************************************* - TEST(test_add_lvalue_reference) - { -#if ETL_USING_CPP17 - CHECK(!std::is_lvalue_reference_v::type>); - CHECK(std::is_lvalue_reference_v::type>); - CHECK(std::is_lvalue_reference_v::type>); - CHECK(std::is_lvalue_reference_v::type>); - CHECK(std::is_lvalue_reference_v::type>); -#else -#endif - } - - //************************************************************************* - TEST(test_add_rvalue_reference) - { -#if ETL_USING_CPP17 - CHECK(!std::is_rvalue_reference_v::type>); - CHECK(std::is_rvalue_reference_v::type>); - CHECK(std::is_rvalue_reference_v::type>); - CHECK(!std::is_rvalue_reference_v::type>); - CHECK(std::is_rvalue_reference_v::type>); -#else -#endif - } - - //************************************************************************* - TEST(test_is_lvalue_reference) - { -#if ETL_USING_CPP17 - CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); - CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); - CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); - CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); - CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); -#else -#endif - } - - //************************************************************************* - TEST(test_is_rvalue_reference) - { -#if ETL_USING_CPP17 - CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); - CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); - CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); - CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); - CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); -#else - CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); - CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); - CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); - CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); - CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); -#endif - } - - //************************************************************************* -#if ETL_USING_CPP17 - #define CHECK_EQUAL_FOR_TYPE(type) CHECK_EQUAL(std::is_enum_v, etl::is_enum_v) -#else - #define CHECK_EQUAL_FOR_TYPE(type) CHECK_EQUAL(std::is_enum::value, etl::is_enum::value) -#endif - - TEST(test_is_enum) - { - CHECK_EQUAL_FOR_TYPE(void); - CHECK_EQUAL_FOR_TYPE(void*); - CHECK_EQUAL_FOR_TYPE(int); - CHECK_EQUAL_FOR_TYPE(int*); - CHECK_EQUAL_FOR_TYPE(ToAny); - CHECK_EQUAL_FOR_TYPE(NotDefaultConstructable); - CHECK_EQUAL_FOR_TYPE(Enum); - CHECK_EQUAL_FOR_TYPE(Enum&); - CHECK_EQUAL_FOR_TYPE(Enum&&); - CHECK_EQUAL_FOR_TYPE(Enum*); - CHECK_EQUAL_FOR_TYPE(const Enum); - CHECK_EQUAL_FOR_TYPE(volatile Enum); - CHECK_EQUAL_FOR_TYPE(const volatile Enum); - CHECK_EQUAL_FOR_TYPE(EnumClass); - CHECK_EQUAL_FOR_TYPE(EnumClass&); - CHECK_EQUAL_FOR_TYPE(EnumClass&&); - CHECK_EQUAL_FOR_TYPE(EnumClass*); - CHECK_EQUAL_FOR_TYPE(const EnumClass); - CHECK_EQUAL_FOR_TYPE(volatile EnumClass); - CHECK_EQUAL_FOR_TYPE(const volatile EnumClass); - - } - #undef CHECK_EQUAL_FOR_TYPE - - //************************************************************************* - TEST(test_integral_constants) - { -#if ETL_USING_CPP17 - CHECK_EQUAL(1, (etl::integral_constant_v)); - CHECK((std::is_same_v::value_type>)); - - CHECK_EQUAL(false, etl::bool_constant_v); - CHECK_EQUAL(true, etl::bool_constant_v); - CHECK((std::is_same_v::value_type>)); - - CHECK_EQUAL(true, etl::negation_v>); - CHECK_EQUAL(false, etl::negation_v>); - CHECK((std::is_same_v::value_type>)); -#else - CHECK_EQUAL(1, (etl::integral_constant::value)); - CHECK((std::is_same::value_type>::value)); - - CHECK_EQUAL(false, (etl::bool_constant::value)); - CHECK_EQUAL(true, (etl::bool_constant::value)); - CHECK((std::is_same::value_type>::value)); - - CHECK_EQUAL(true, etl::negation>::value); - CHECK_EQUAL(false, etl::negation>::value); - CHECK((std::is_same::value_type>::value)); -#endif - } - - //************************************************************************* - TEST(test_are_all_same) - { -#if ETL_USING_CPP17 - CHECK((etl::are_all_same_v == true)); - CHECK((etl::are_all_same_v == false)); -#else - CHECK((etl::are_all_same::value == true)); - CHECK((etl::are_all_same::value == false)); -#endif - } - - //************************************************************************* - TEST(test_conjunction) - { -#if ETL_USING_CPP17 - CHECK_TRUE((etl::conjunction_v)); - CHECK_FALSE((etl::conjunction_v)); -#else - CHECK_TRUE((etl::conjunction::value)); - CHECK_FALSE((etl::conjunction::value)); -#endif - } - - //************************************************************************* - TEST(test_disjunction) - { -#if ETL_USING_CPP17 - CHECK_TRUE((etl::disjunction_v)); - CHECK_FALSE((etl::disjunction_v)); -#else - CHECK_TRUE((etl::disjunction::value)); - CHECK_FALSE((etl::disjunction::value)); -#endif - } - - //************************************************************************* - TEST(test_exclusive_disjunction) - { -#if ETL_USING_CPP17 - CHECK_TRUE((etl::exclusive_disjunction_v)); - CHECK_FALSE((etl::exclusive_disjunction_v)); - CHECK_FALSE((etl::exclusive_disjunction_v)); -#else - CHECK_TRUE((etl::exclusive_disjunction::value)); - CHECK_FALSE((etl::exclusive_disjunction::value)); - CHECK_FALSE((etl::exclusive_disjunction::value)); -#endif - } - - //************************************************************************* - TEST(test_is_assignable) - { -#if ETL_USING_CPP17 - CHECK((etl::is_assignable_v) == (std::is_assignable_v)); - CHECK((etl::is_assignable_v) == (std::is_assignable_v)); - CHECK((etl::is_assignable_v) == (std::is_assignable_v)); -#else - CHECK((etl::is_assignable::value) == (std::is_assignable::value)); - CHECK((etl::is_assignable::value) == (std::is_assignable::value)); - CHECK((etl::is_assignable::value) == (std::is_assignable::value)); -#endif - } - - //************************************************************************* - TEST(test_is_lvalue_assignable) - { -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_lvalue_assignable_v)); - CHECK(!(etl::is_lvalue_assignable_v)); - CHECK((etl::is_lvalue_assignable_v)); -#else - CHECK((etl::is_lvalue_assignable::value)); - CHECK(!(etl::is_lvalue_assignable::value)); - CHECK((etl::is_lvalue_assignable::value)); -#endif -#endif - } - - //************************************************************************* - TEST(test_is_constructible) - { -#if ETL_USING_CPP17 - CHECK((etl::is_constructible_v) == (std::is_constructible_v)); - CHECK((etl::is_constructible_v) == (std::is_constructible_v)); - CHECK((etl::is_constructible_v) == (std::is_constructible_v)); - CHECK((etl::is_constructible_v) == (std::is_constructible_v)); -#else - CHECK((etl::is_constructible::value) == (std::is_constructible::value)); - CHECK((etl::is_constructible::value) == (std::is_constructible::value)); - CHECK((etl::is_constructible::value) == (std::is_constructible::value)); - CHECK((etl::is_constructible::value) == (std::is_constructible::value)); -#endif - } - - //************************************************************************* - TEST(test_is_default_constructible) - { -#if ETL_USING_CPP17 - CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); - CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); - CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); - CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); -#else - CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); - CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); - CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); - CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); -#endif - } - - //************************************************************************* - TEST(test_is_copy_constructible) - { -#if ETL_USING_CPP17 - CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); - CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); - CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); -#else - CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); - CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); - CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); -#endif - } - - //************************************************************************* - TEST(test_is_move_constructible) - { -#if ETL_USING_CPP17 - CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); - CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); - CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); -#else - CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); - CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); - CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); -#endif - } - - //************************************************************************* - TEST(test_is_trivially_constructible) - { -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); - CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); - CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); -#else - CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); - CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); - CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); -#endif -#endif - } - - //************************************************************************* - TEST(test_is_trivially_copy_constructible) - { -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); - CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); - CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); -#else - CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); - CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); - CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); -#endif -#endif - } - - //************************************************************************* - TEST(test_is_trivially_destructible) - { -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); - CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); - CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); -#else - CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); - CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); - CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); -#endif -#endif - } - - //************************************************************************* - TEST(test_is_trivially_copy_assignable) - { -#if (!(defined(ETL_COMPILER_GCC) && defined(ETL_USE_TYPE_TRAITS_BUILTINS))) -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); - CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); - CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); -#else - CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); - CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); - CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); -#endif -#endif -#endif - } - - //************************************************************************* - TEST(test_is_trivially_copyable) - { -#if (!(defined(ETL_COMPILER_GCC) && defined(ETL_USE_TYPE_TRAITS_BUILTINS))) -#if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) -#if ETL_USING_CPP17 - CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); - CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); - CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); -#else - CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); - CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); - CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); -#endif -#endif -#endif - } - - //************************************************************************* - TEST(test_is_base_of_any) - { - struct Base {}; - struct D1 : Base {}; - struct D2 : Base {}; - struct D3 : Base {}; - struct D4 {}; - -#if ETL_USING_CPP17 - CHECK_TRUE(bool(etl::is_base_of_any_v)); - CHECK_FALSE(bool(etl::is_base_of_any_v)); -#else - CHECK_TRUE(bool(etl::is_base_of_any::value)); - CHECK_FALSE(bool(etl::is_base_of_any::value)); -#endif - } - - //************************************************************************* - TEST(test_is_base_of_all) - { - struct Base {}; - struct D1 : Base {}; - struct D2 : Base {}; - struct D3 : Base {}; - struct D4 {}; - -#if ETL_USING_CPP17 - CHECK_TRUE(bool(etl::is_base_of_all_v)); - CHECK_FALSE(bool(etl::is_base_of_all_v)); -#else - CHECK_TRUE(bool(etl::is_base_of_all::value)); - CHECK_FALSE(bool(etl::is_base_of_all::value)); -#endif - } - - //************************************************************************* - TEST(test_nth_base) - { - struct D0 { }; - struct D1 : D0 { using base_type = D0; }; - struct D2 : D1 { using base_type = D1; }; - struct D3 : D2 { using base_type = D2; }; - struct D4 : D3 { using base_type = D3; }; - - CHECK_TRUE((std::is_same>::value)); - CHECK_TRUE((std::is_same>::value)); - CHECK_TRUE((std::is_same>::value)); - CHECK_TRUE((std::is_same>::value)); - CHECK_TRUE((std::is_same>::value)); - } - - //************************************************************************* - TEST(test_type_identity) - { - CHECK_CLOSE(type_identity_test_add(1.5f, 2), 3.5f, 0.01f); - } - - //************************************************************************* -#if ETL_USING_BUILTIN_UNDERLYING_TYPE - TEST(test_underlying_type) - { - enum enum0_t : char + //************************************************************************* + TEST(test_conditional_integral_constant) { - }; + int v1 = etl::conditional_integral_constant::value; + int v2 = etl::conditional_integral_constant::value; - enum enum1_t : uint32_t + CHECK_EQUAL(1, v1); + CHECK_EQUAL(2, v2); + } + + //************************************************************************* + TEST(test_size_of) { - }; + #if ETL_USING_CPP17 + CHECK_EQUAL(1, etl::size_of_v); + CHECK_EQUAL(1, etl::size_of_v); + CHECK_EQUAL(2, etl::size_of_v); + CHECK_EQUAL(4, etl::size_of_v); + CHECK_EQUAL(20, etl::size_of_v); + #else + CHECK_EQUAL(1, etl::size_of::value); + CHECK_EQUAL(1, etl::size_of::value); + CHECK_EQUAL(2, etl::size_of::value); + CHECK_EQUAL(4, etl::size_of::value); + CHECK_EQUAL(20, etl::size_of::value); + #endif + } - enum class enum2_t : short + //************************************************************************* + TEST(test_is_convertible) { - }; + #if ETL_USING_CPP17 + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK((etl::is_convertible_v)); + CHECK(!(etl::is_convertible_v)); + CHECK(!(etl::is_convertible_v)); + CHECK(!(etl::is_convertible_v)); + CHECK(!(etl::is_convertible_v)); + #else + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK((etl::is_convertible::value)); + CHECK(!(etl::is_convertible::value)); + CHECK(!(etl::is_convertible::value)); + CHECK(!(etl::is_convertible::value)); + CHECK(!(etl::is_convertible::value)); + #endif + } - enum class enum3_t : size_t + //************************************************************************* + TEST(test_add_lvalue_reference) { - }; + #if ETL_USING_CPP17 + CHECK(!std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + #else + #endif + } - using enum4_t = enum1_t; - using enum5_t = std::add_const::type; + //************************************************************************* + TEST(test_add_rvalue_reference) + { + #if ETL_USING_CPP17 + CHECK(!std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + CHECK(!std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + #else + #endif + } - CHECK_TRUE((std::is_same::type, char>::value)); - CHECK_TRUE((std::is_same::type, uint32_t>::value)); - CHECK_TRUE((std::is_same::type, short>::value)); - CHECK_TRUE((std::is_same::type, size_t>::value)); - CHECK_TRUE((std::is_same::type, uint32_t>::value)); - CHECK_TRUE((std::is_same::type, short>::value)); -#if ETL_USING_CPP11 - CHECK_TRUE((std::is_same, char>::value)); - CHECK_TRUE((std::is_same, uint32_t>::value)); - CHECK_TRUE((std::is_same, short>::value)); - CHECK_TRUE((std::is_same, size_t>::value)); - CHECK_TRUE((std::is_same, uint32_t>::value)); - CHECK_TRUE((std::is_same, short>::value)); -#endif - } -#endif + //************************************************************************* + TEST(test_is_lvalue_reference) + { + #if ETL_USING_CPP17 + CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etl::is_lvalue_reference_v); + #else + #endif + } - //************************************************************************* - TEST(test_has_duplicates) - { -#if ETL_USING_CPP17 - CHECK_FALSE((etl::has_duplicates_v)); - CHECK_FALSE((etl::has_duplicates_v)); - CHECK_TRUE((etl::has_duplicates_v)); -#else - CHECK_FALSE((etl::has_duplicates::value)); - CHECK_FALSE((etl::has_duplicates::value)); - CHECK_TRUE((etl::has_duplicates::value)); -#endif - } + //************************************************************************* + TEST(test_is_rvalue_reference) + { + #if ETL_USING_CPP17 + CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); + CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); + CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); + CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); + CHECK_EQUAL(std::is_rvalue_reference_v, etl::is_rvalue_reference_v); + #else + CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); + CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); + CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); + CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); + CHECK_EQUAL(std::is_rvalue_reference::value, etl::is_rvalue_reference::value); + #endif + } - //************************************************************************* - TEST(test_has_duplicates_of) - { -#if ETL_USING_CPP17 - CHECK_FALSE((etl::has_duplicates_of_v)); - CHECK_TRUE((etl::has_duplicates_of_v)); // char is duplicated. - CHECK_FALSE((etl::has_duplicates_of_v)); // int is not duplicated. -#else - CHECK_FALSE((etl::has_duplicates_of::value)); - CHECK_TRUE((etl::has_duplicates_of::value)); // char is duplicated. - CHECK_FALSE((etl::has_duplicates_of::value)); // int is not duplicated. -#endif - } + //************************************************************************* + #if ETL_USING_CPP17 + #define CHECK_EQUAL_FOR_TYPE(type) CHECK_EQUAL(std::is_enum_v, etl::is_enum_v) + #else + #define CHECK_EQUAL_FOR_TYPE(type) CHECK_EQUAL(std::is_enum::value, etl::is_enum::value) + #endif - //************************************************************************* - TEST(test_count_of) - { -#if ETL_USING_CPP17 - CHECK_EQUAL(0, (etl::count_of_v)); - CHECK_EQUAL(0, (etl::count_of_v)); - CHECK_EQUAL(1, (etl::count_of_v)); - CHECK_EQUAL(1, (etl::count_of_v)); - CHECK_EQUAL(2, (etl::count_of_v)); -#else - CHECK_EQUAL(0, (etl::count_of::value)); - CHECK_EQUAL(0, (etl::count_of::value)); - CHECK_EQUAL(1, (etl::count_of::value)); - CHECK_EQUAL(1, (etl::count_of::value)); - CHECK_EQUAL(2, (etl::count_of::value)); -#endif - } + TEST(test_is_enum) + { + CHECK_EQUAL_FOR_TYPE(void); + CHECK_EQUAL_FOR_TYPE(void*); + CHECK_EQUAL_FOR_TYPE(int); + CHECK_EQUAL_FOR_TYPE(int*); + CHECK_EQUAL_FOR_TYPE(ToAny); + CHECK_EQUAL_FOR_TYPE(NotDefaultConstructable); + CHECK_EQUAL_FOR_TYPE(Enum); + CHECK_EQUAL_FOR_TYPE(Enum&); + CHECK_EQUAL_FOR_TYPE(Enum&&); + CHECK_EQUAL_FOR_TYPE(Enum*); + CHECK_EQUAL_FOR_TYPE(const Enum); + CHECK_EQUAL_FOR_TYPE(volatile Enum); + CHECK_EQUAL_FOR_TYPE(const volatile Enum); + CHECK_EQUAL_FOR_TYPE(EnumClass); + CHECK_EQUAL_FOR_TYPE(EnumClass&); + CHECK_EQUAL_FOR_TYPE(EnumClass&&); + CHECK_EQUAL_FOR_TYPE(EnumClass*); + CHECK_EQUAL_FOR_TYPE(const EnumClass); + CHECK_EQUAL_FOR_TYPE(volatile EnumClass); + CHECK_EQUAL_FOR_TYPE(const volatile EnumClass); - //************************************************************************* - TEST(test_is_specialization) - { -#if ETL_USING_CPP17 - CHECK_TRUE((etl::is_specialization_v, specialized>)); - CHECK_FALSE((etl::is_specialization_v, specialized>)); -#else - CHECK_TRUE((etl::is_specialization, specialized>::value)); - CHECK_FALSE((etl::is_specialization, specialized>::value)); -#endif - } + } + #undef CHECK_EQUAL_FOR_TYPE -#if ETL_USING_CPP11 - //************************************************************************* - TEST(test_is_constant_evaluated) - { - constexpr bool c0 = etl::is_constant_evaluated(); -#if !ETL_USING_CPP23 && defined(ETL_COMPILER_MICROSOFT) - // Not supported on MSVC via __has_builtin, see determine_builtin_support.h - CHECK_FALSE(c0); -#else - CHECK_TRUE(c0); -#endif + //************************************************************************* + TEST(test_integral_constants) + { + #if ETL_USING_CPP17 + CHECK_EQUAL(1, (etl::integral_constant_v)); + CHECK((std::is_same_v::value_type>)); - volatile int i = 1; - const bool c1 = (((i == 1) && etl::is_constant_evaluated()) ? true : false); - CHECK_FALSE(c1); - } -#endif + CHECK_EQUAL(false, etl::bool_constant_v); + CHECK_EQUAL(true, etl::bool_constant_v); + CHECK((std::is_same_v::value_type>)); - //************************************************************************* - // Basic cv for member function pointers - TEST(test_is_member_function_pointer) - { - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_EQUAL(true, etl::negation_v>); + CHECK_EQUAL(false, etl::negation_v>); + CHECK((std::is_same_v::value_type>)); + #else + CHECK_EQUAL(1, (etl::integral_constant::value)); + CHECK((std::is_same::value_type>::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_EQUAL(false, (etl::bool_constant::value)); + CHECK_EQUAL(true, (etl::bool_constant::value)); + CHECK((std::is_same::value_type>::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_EQUAL(true, etl::negation>::value); + CHECK_EQUAL(false, etl::negation>::value); + CHECK((std::is_same::value_type>::value)); + #endif + } -#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); + //************************************************************************* + TEST(test_are_all_same) + { + #if ETL_USING_CPP17 + CHECK((etl::are_all_same_v == true)); + CHECK((etl::are_all_same_v == false)); + #else + CHECK((etl::are_all_same::value == true)); + CHECK((etl::are_all_same::value == false)); + #endif + } - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); + //************************************************************************* + TEST(test_conjunction) + { + #if ETL_USING_CPP17 + CHECK_TRUE((etl::conjunction_v)); + CHECK_FALSE((etl::conjunction_v)); + #else + CHECK_TRUE((etl::conjunction::value)); + CHECK_FALSE((etl::conjunction::value)); + #endif + } - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); -#endif + //************************************************************************* + TEST(test_disjunction) + { + #if ETL_USING_CPP17 + CHECK_TRUE((etl::disjunction_v)); + CHECK_FALSE((etl::disjunction_v)); + #else + CHECK_TRUE((etl::disjunction::value)); + CHECK_FALSE((etl::disjunction::value)); + #endif + } - CHECK_TRUE((etl::is_member_function_pointer::value)); - CHECK_TRUE((etl::is_member_function_pointer::value)); - } + //************************************************************************* + TEST(test_exclusive_disjunction) + { + #if ETL_USING_CPP17 + CHECK_TRUE((etl::exclusive_disjunction_v)); + CHECK_FALSE((etl::exclusive_disjunction_v)); + CHECK_FALSE((etl::exclusive_disjunction_v)); + #else + CHECK_TRUE((etl::exclusive_disjunction::value)); + CHECK_FALSE((etl::exclusive_disjunction::value)); + CHECK_FALSE((etl::exclusive_disjunction::value)); + #endif + } - //************************************************************************* - // Negative tests for member function pointer trait - TEST(test_is_member_function_pointer_negative) - { - (void)f(0); + //************************************************************************* + TEST(test_is_assignable) + { + #if ETL_USING_CPP17 + CHECK((etl::is_assignable_v) == (std::is_assignable_v)); + CHECK((etl::is_assignable_v) == (std::is_assignable_v)); + CHECK((etl::is_assignable_v) == (std::is_assignable_v)); + #else + CHECK((etl::is_assignable::value) == (std::is_assignable::value)); + CHECK((etl::is_assignable::value) == (std::is_assignable::value)); + CHECK((etl::is_assignable::value) == (std::is_assignable::value)); + #endif + } - // Free function pointer - CHECK_FALSE((etl::is_member_function_pointer::value)); + //************************************************************************* + TEST(test_is_lvalue_assignable) + { + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_lvalue_assignable_v)); + CHECK(!(etl::is_lvalue_assignable_v)); + CHECK((etl::is_lvalue_assignable_v)); + #else + CHECK((etl::is_lvalue_assignable::value)); + CHECK(!(etl::is_lvalue_assignable::value)); + CHECK((etl::is_lvalue_assignable::value)); + #endif + #endif + } - // Member object pointer - CHECK_FALSE((etl::is_member_function_pointer::value)); + //************************************************************************* + TEST(test_is_constructible) + { + #if ETL_USING_CPP17 + CHECK((etl::is_constructible_v) == (std::is_constructible_v)); + CHECK((etl::is_constructible_v) == (std::is_constructible_v)); + CHECK((etl::is_constructible_v) == (std::is_constructible_v)); + CHECK((etl::is_constructible_v) == (std::is_constructible_v)); + #else + CHECK((etl::is_constructible::value) == (std::is_constructible::value)); + CHECK((etl::is_constructible::value) == (std::is_constructible::value)); + CHECK((etl::is_constructible::value) == (std::is_constructible::value)); + CHECK((etl::is_constructible::value) == (std::is_constructible::value)); + #endif + } - // Plain function type (not pointer) - CHECK_FALSE((etl::is_member_function_pointer::value)); + //************************************************************************* + TEST(test_is_default_constructible) + { + #if ETL_USING_CPP17 + CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); + CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); + CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); + CHECK((etl::is_default_constructible_v) == (std::is_default_constructible_v)); + #else + CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); + CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); + CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); + CHECK((etl::is_default_constructible::value) == (std::is_default_constructible::value)); + #endif + } - // Non-function type - CHECK_FALSE((etl::is_member_function_pointer::value)); - } + //************************************************************************* + TEST(test_is_copy_constructible) + { + #if ETL_USING_CPP17 + CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); + CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); + CHECK((etl::is_copy_constructible_v) == (std::is_copy_constructible_v)); + #else + CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); + CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); + CHECK((etl::is_copy_constructible::value) == (std::is_copy_constructible::value)); + #endif + } - //************************************************************************* - // Member object pointer trait - TEST(test_is_member_object_pointer) - { - CHECK_TRUE((etl::is_member_object_pointer::value)); + //************************************************************************* + TEST(test_is_move_constructible) + { + #if ETL_USING_CPP17 + CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); + CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); + CHECK((etl::is_move_constructible_v) == (std::is_move_constructible_v)); + #else + CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); + CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); + CHECK((etl::is_move_constructible::value) == (std::is_move_constructible::value)); + #endif + } - // Not a member object pointer - CHECK_FALSE((etl::is_member_object_pointer::value)); - CHECK_FALSE((etl::is_member_object_pointer::value)); - } + //************************************************************************* + TEST(test_is_trivially_constructible) + { + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); + CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); + CHECK((etl::is_trivially_constructible_v) == (std::is_trivially_constructible_v)); + #else + CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); + CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); + CHECK((etl::is_trivially_constructible::value) == (std::is_trivially_constructible::value)); + #endif + #endif + } - //************************************************************************* - // Member pointer (either member object or member function pointer) - TEST(test_is_member_pointer_any) - { - CHECK_TRUE((etl::is_member_pointer::value)); - CHECK_TRUE((etl::is_member_pointer::value)); + //************************************************************************* + TEST(test_is_trivially_copy_constructible) + { + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); + CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); + CHECK((etl::is_trivially_copy_constructible_v) == (std::is_trivially_copy_constructible_v)); + #else + CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); + CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); + CHECK((etl::is_trivially_copy_constructible::value) == (std::is_trivially_copy_constructible::value)); + #endif + #endif + } - // Not member pointers - CHECK_FALSE((etl::is_member_pointer::value)); - CHECK_FALSE((etl::is_member_pointer::value)); - } + //************************************************************************* + TEST(test_is_trivially_destructible) + { + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); + CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); + CHECK((etl::is_trivially_destructible_v) == (std::is_trivially_destructible_v)); + #else + CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); + CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); + CHECK((etl::is_trivially_destructible::value) == (std::is_trivially_destructible::value)); + #endif + #endif + } - //************************************************************************* - // Function type detection - TEST(test_is_function) - { - (void)f(0); - (void)fvar(); - (void)fvar2(0); - (void)ft(0, 0.0); + //************************************************************************* + TEST(test_is_trivially_copy_assignable) + { + #if (!(defined(ETL_COMPILER_GCC) && defined(ETL_USE_TYPE_TRAITS_BUILTINS))) + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); + CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); + CHECK((etl::is_trivially_copy_assignable_v) == (std::is_trivially_copy_assignable_v)); + #else + CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); + CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); + CHECK((etl::is_trivially_copy_assignable::value) == (std::is_trivially_copy_assignable::value)); + #endif + #endif + #endif + } - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function)>::value)); + //************************************************************************* + TEST(test_is_trivially_copyable) + { + #if (!(defined(ETL_COMPILER_GCC) && defined(ETL_USE_TYPE_TRAITS_BUILTINS))) + #if ETL_USING_STL || defined(ETL_USE_TYPE_TRAITS_BUILTINS) || defined(ETL_USER_DEFINED_TYPE_TRAITS) + #if ETL_USING_CPP17 + CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); + CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); + CHECK((etl::is_trivially_copyable_v) == (std::is_trivially_copyable_v)); + #else + CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); + CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); + CHECK((etl::is_trivially_copyable::value) == (std::is_trivially_copyable::value)); + #endif + #endif + #endif + } -#if ETL_HAS_NOEXCEPT_FUNCTION_TYPE - (void)fn(0); - (void)fnvar(); - (void)fnvar2(0); - (void)fnt(0, 0.0); + //************************************************************************* + TEST(test_is_base_of_any) + { + struct Base {}; + struct D1 : Base {}; + struct D2 : Base {}; + struct D3 : Base {}; + struct D4 {}; - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function::value)); - CHECK_TRUE((etl::is_function)>::value)); -#endif + #if ETL_USING_CPP17 + CHECK_TRUE(bool(etl::is_base_of_any_v)); + CHECK_FALSE(bool(etl::is_base_of_any_v)); + #else + CHECK_TRUE(bool(etl::is_base_of_any::value)); + CHECK_FALSE(bool(etl::is_base_of_any::value)); + #endif + } - CHECK_FALSE((etl::is_function::value)); - CHECK_FALSE((etl::is_function::value)); - CHECK_FALSE((etl::is_function::value)); - CHECK_FALSE((etl::is_function::value)); // pointer, not function + //************************************************************************* + TEST(test_is_base_of_all) + { + struct Base {}; + struct D1 : Base {}; + struct D2 : Base {}; + struct D3 : Base {}; + struct D4 {}; + + #if ETL_USING_CPP17 + CHECK_TRUE(bool(etl::is_base_of_all_v)); + CHECK_FALSE(bool(etl::is_base_of_all_v)); + #else + CHECK_TRUE(bool(etl::is_base_of_all::value)); + CHECK_FALSE(bool(etl::is_base_of_all::value)); + #endif + } + + //************************************************************************* + TEST(test_nth_base) + { + struct D0 { }; + struct D1 : D0 { using base_type = D0; }; + struct D2 : D1 { using base_type = D1; }; + struct D3 : D2 { using base_type = D2; }; + struct D4 : D3 { using base_type = D3; }; + + CHECK_TRUE((std::is_same>::value)); + CHECK_TRUE((std::is_same>::value)); + CHECK_TRUE((std::is_same>::value)); + CHECK_TRUE((std::is_same>::value)); + CHECK_TRUE((std::is_same>::value)); + } + + //************************************************************************* + TEST(test_type_identity) + { + CHECK_CLOSE(type_identity_test_add(1.5f, 2), 3.5f, 0.01f); + } + + //************************************************************************* + #if ETL_USING_BUILTIN_UNDERLYING_TYPE + TEST(test_underlying_type) + { + enum enum0_t : char + { + }; + + enum enum1_t : uint32_t + { + }; + + enum class enum2_t : short + { + }; + + enum class enum3_t : size_t + { + }; + + using enum4_t = enum1_t; + using enum5_t = std::add_const::type; + + CHECK_TRUE((std::is_same::type, char>::value)); + CHECK_TRUE((std::is_same::type, uint32_t>::value)); + CHECK_TRUE((std::is_same::type, short>::value)); + CHECK_TRUE((std::is_same::type, size_t>::value)); + CHECK_TRUE((std::is_same::type, uint32_t>::value)); + CHECK_TRUE((std::is_same::type, short>::value)); + #if ETL_USING_CPP11 + CHECK_TRUE((std::is_same, char>::value)); + CHECK_TRUE((std::is_same, uint32_t>::value)); + CHECK_TRUE((std::is_same, short>::value)); + CHECK_TRUE((std::is_same, size_t>::value)); + CHECK_TRUE((std::is_same, uint32_t>::value)); + CHECK_TRUE((std::is_same, short>::value)); + #endif + } + #endif + + //************************************************************************* + TEST(test_has_duplicates) + { + #if ETL_USING_CPP17 + CHECK_FALSE((etl::has_duplicates_v)); + CHECK_FALSE((etl::has_duplicates_v)); + CHECK_TRUE((etl::has_duplicates_v)); + #else + CHECK_FALSE((etl::has_duplicates::value)); + CHECK_FALSE((etl::has_duplicates::value)); + CHECK_TRUE((etl::has_duplicates::value)); + #endif + } + + //************************************************************************* + TEST(test_has_duplicates_of) + { + #if ETL_USING_CPP17 + CHECK_FALSE((etl::has_duplicates_of_v)); + CHECK_TRUE((etl::has_duplicates_of_v)); // char is duplicated. + CHECK_FALSE((etl::has_duplicates_of_v)); // int is not duplicated. + #else + CHECK_FALSE((etl::has_duplicates_of::value)); + CHECK_TRUE((etl::has_duplicates_of::value)); // char is duplicated. + CHECK_FALSE((etl::has_duplicates_of::value)); // int is not duplicated. + #endif + } + + //************************************************************************* + TEST(test_count_of) + { + #if ETL_USING_CPP17 + CHECK_EQUAL(0, (etl::count_of_v)); + CHECK_EQUAL(0, (etl::count_of_v)); + CHECK_EQUAL(1, (etl::count_of_v)); + CHECK_EQUAL(1, (etl::count_of_v)); + CHECK_EQUAL(2, (etl::count_of_v)); + #else + CHECK_EQUAL(0, (etl::count_of::value)); + CHECK_EQUAL(0, (etl::count_of::value)); + CHECK_EQUAL(1, (etl::count_of::value)); + CHECK_EQUAL(1, (etl::count_of::value)); + CHECK_EQUAL(2, (etl::count_of::value)); + #endif + } + + //************************************************************************* + TEST(test_is_specialization) + { + #if ETL_USING_CPP17 + CHECK_TRUE((etl::is_specialization_v, specialized>)); + CHECK_FALSE((etl::is_specialization_v, specialized>)); + #else + CHECK_TRUE((etl::is_specialization, specialized>::value)); + CHECK_FALSE((etl::is_specialization, specialized>::value)); + #endif + } + + #if ETL_USING_CPP11 + //************************************************************************* + TEST(test_is_constant_evaluated) + { + constexpr bool c0 = etl::is_constant_evaluated(); + #if !ETL_USING_CPP23 && defined(ETL_COMPILER_MICROSOFT) + // Not supported on MSVC via __has_builtin, see determine_builtin_support.h + CHECK_FALSE(c0); + #else + CHECK_TRUE(c0); + #endif + + volatile int i = 1; + const bool c1 = (((i == 1) && etl::is_constant_evaluated()) ? true : false); + CHECK_FALSE(c1); + } + #endif + + //************************************************************************* + // Basic cv for member function pointers + TEST(test_is_member_function_pointer) + { + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + + #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + #endif + + CHECK_TRUE((etl::is_member_function_pointer::value)); + CHECK_TRUE((etl::is_member_function_pointer::value)); + } + + //************************************************************************* + // Negative tests for member function pointer trait + TEST(test_is_member_function_pointer_negative) + { + (void)f(0); + + // Free function pointer + CHECK_FALSE((etl::is_member_function_pointer::value)); + + // Member object pointer + CHECK_FALSE((etl::is_member_function_pointer::value)); + + // Plain function type (not pointer) + CHECK_FALSE((etl::is_member_function_pointer::value)); + + // Non-function type + CHECK_FALSE((etl::is_member_function_pointer::value)); + } + + //************************************************************************* + // Member object pointer trait + TEST(test_is_member_object_pointer) + { + CHECK_TRUE((etl::is_member_object_pointer::value)); + + // Not a member object pointer + CHECK_FALSE((etl::is_member_object_pointer::value)); + CHECK_FALSE((etl::is_member_object_pointer::value)); + } + + //************************************************************************* + // Member pointer (either member object or member function pointer) + TEST(test_is_member_pointer_any) + { + CHECK_TRUE((etl::is_member_pointer::value)); + CHECK_TRUE((etl::is_member_pointer::value)); + + // Not member pointers + CHECK_FALSE((etl::is_member_pointer::value)); + CHECK_FALSE((etl::is_member_pointer::value)); + } + + //************************************************************************* + // Function type detection + TEST(test_is_function) + { + (void)f(0); + (void)fvar(); + (void)fvar2(0); + (void)ft(0, 0.0); + + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function)>::value)); + + #if ETL_HAS_NOEXCEPT_FUNCTION_TYPE + (void)fn(0); + (void)fnvar(); + (void)fnvar2(0); + (void)fnt(0, 0.0); + + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function::value)); + CHECK_TRUE((etl::is_function)>::value)); + #endif + + CHECK_FALSE((etl::is_function::value)); + CHECK_FALSE((etl::is_function::value)); + CHECK_FALSE((etl::is_function::value)); + CHECK_FALSE((etl::is_function::value)); // pointer, not function + } } } diff --git a/test/test_unaligned_type.cpp b/test/test_unaligned_type.cpp index 96827cba..f5be4d09 100644 --- a/test/test_unaligned_type.cpp +++ b/test/test_unaligned_type.cpp @@ -1030,7 +1030,7 @@ namespace CHECK_EQUAL(0x12, bev0); CHECK_EQUAL(0x34, bev1); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_unaligned_type_ext.cpp b/test/test_unaligned_type_ext.cpp index 5d3b5975..a0ff0183 100644 --- a/test/test_unaligned_type_ext.cpp +++ b/test/test_unaligned_type_ext.cpp @@ -1520,7 +1520,7 @@ namespace CHECK_EQUAL(0x12, bev0); CHECK_EQUAL(0x34, bev1); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_uncopyable.cpp b/test/test_uncopyable.cpp index f059dfa7..e0750290 100644 --- a/test/test_uncopyable.cpp +++ b/test/test_uncopyable.cpp @@ -62,5 +62,5 @@ namespace uc3 = uc1; // compile error } #endif - }; + } } diff --git a/test/test_unordered_map.cpp b/test/test_unordered_map.cpp index c38fb0dd..f326d037 100644 --- a/test/test_unordered_map.cpp +++ b/test/test_unordered_map.cpp @@ -1431,5 +1431,5 @@ namespace CHECK_TRUE(data.contains("FF")); CHECK_FALSE(data.contains(not_inserted)); } - }; + } } diff --git a/test/test_unordered_multimap.cpp b/test/test_unordered_multimap.cpp index 716636e0..dff743b2 100644 --- a/test/test_unordered_multimap.cpp +++ b/test/test_unordered_multimap.cpp @@ -1248,5 +1248,5 @@ namespace CHECK_TRUE(data.contains("FF")); CHECK_FALSE(data.contains(not_inserted)); } - }; + } } diff --git a/test/test_unordered_multiset.cpp b/test/test_unordered_multiset.cpp index 27bfe310..0992e4e6 100644 --- a/test/test_unordered_multiset.cpp +++ b/test/test_unordered_multiset.cpp @@ -1103,5 +1103,5 @@ namespace CHECK_TRUE(data.contains("FF")); CHECK_FALSE(data.contains(not_inserted)); } - }; + } } diff --git a/test/test_unordered_set.cpp b/test/test_unordered_set.cpp index 189f9761..c9a4ac96 100644 --- a/test/test_unordered_set.cpp +++ b/test/test_unordered_set.cpp @@ -1068,5 +1068,5 @@ namespace CHECK_TRUE(data.contains("FF")); CHECK_FALSE(data.contains(not_inserted)); } - }; + } } diff --git a/test/test_user_type.cpp b/test/test_user_type.cpp index 50523ad4..27c2f95c 100644 --- a/test/test_user_type.cpp +++ b/test/test_user_type.cpp @@ -175,8 +175,8 @@ namespace TEST(test_and_equal) { CompassDirection value = CompassDirection::North; - value &= 0xAAAAAAAAUL; - CompassDirection expected = CompassDirection(CompassDirection::North & 0xAAAAAAAAUL); + value &= static_cast(0xAAAAAAAAUL); + CompassDirection expected = CompassDirection(CompassDirection::North & static_cast(0xAAAAAAAAUL)); CHECK_EQUAL(expected, value); } @@ -185,8 +185,8 @@ namespace TEST(test_or_equal) { CompassDirection value = CompassDirection::North; - value |= 0xAAAAAAAAUL; - CompassDirection expected = CompassDirection(CompassDirection::North | 0xAAAAAAAAUL); + value |= static_cast(0xAAAAAAAAUL); + CompassDirection expected = CompassDirection(CompassDirection::North | static_cast(0xAAAAAAAAUL)); CHECK_EQUAL(expected, value); } @@ -195,8 +195,8 @@ namespace TEST(test_xor_equal) { CompassDirection value = CompassDirection::North; - value ^= 0xAAAAAAAAUL; - CompassDirection expected = CompassDirection(CompassDirection::North ^ 0xAAAAAAAAUL); + value ^= static_cast(0xAAAAAAAAUL); + CompassDirection expected = CompassDirection(CompassDirection::North ^ static_cast(0xAAAAAAAAUL)); CHECK_EQUAL(expected, value); } @@ -220,5 +220,5 @@ namespace CHECK_EQUAL(expected, value); } - }; + } } diff --git a/test/test_utility.cpp b/test/test_utility.cpp index 60c5163c..1757a499 100644 --- a/test/test_utility.cpp +++ b/test/test_utility.cpp @@ -825,43 +825,43 @@ namespace CHECK_EQUAL(a_b[2], 0x34567890); CHECK_EQUAL(a_b[3], 0x09876543); } - }; #if ETL_USING_CPP17 && !defined(ETL_FORCE_CPP11_NONTYPE) - //********************************* - TEST(test_nontype_t_cpp17) - { - // Test with int - CHECK_TRUE(42 == etl::nontype_t<42>::value); + //********************************* + TEST(test_nontype_t_cpp17) + { + // Test with int + CHECK_TRUE(42 == etl::nontype_t<42>::value); - // Test with bool - CHECK_TRUE(true == etl::nontype_t::value); + // Test with bool + CHECK_TRUE(true == etl::nontype_t::value); - // Test with char - CHECK_TRUE('A' == etl::nontype_t<'A'>::value); + // Test with char + CHECK_TRUE('A' == etl::nontype_t<'A'>::value); - // Test with enum - enum class E : uint8_t { A = 1, B = 2 }; - CHECK_TRUE(E::A == etl::nontype_t::value); - CHECK_TRUE(E::B == etl::nontype_t::value); - } + // Test with enum + enum class E : uint8_t { A = 1, B = 2 }; + CHECK_TRUE(E::A == etl::nontype_t::value); + CHECK_TRUE(E::B == etl::nontype_t::value); + } #elif ETL_USING_CPP11 - enum class E : uint8_t { A = 1, B = 2 }; + enum class E : uint8_t { A = 1, B = 2 }; - TEST(test_nontype_t_cpp11) - { - // Test with int - CHECK_TRUE(42 == (etl::nontype_t::value)); + TEST(test_nontype_t_cpp11) + { + // Test with int + CHECK_TRUE(42 == (etl::nontype_t::value)); - // Test with bool - CHECK_TRUE(true == (etl::nontype_t::value)); + // Test with bool + CHECK_TRUE(true == (etl::nontype_t::value)); - // Test with char - CHECK_TRUE('A' == (etl::nontype_t::value)); + // Test with char + CHECK_TRUE('A' == (etl::nontype_t::value)); - // Test with enum - CHECK_TRUE(E::A == (etl::nontype_t::value)); - CHECK_TRUE(E::B == (etl::nontype_t::value)); - } + // Test with enum + CHECK_TRUE(E::A == (etl::nontype_t::value)); + CHECK_TRUE(E::B == (etl::nontype_t::value)); + } #endif + } } diff --git a/test/test_variance.cpp b/test/test_variance.cpp index b09a7c0f..5a63e464 100644 --- a/test/test_variance.cpp +++ b/test/test_variance.cpp @@ -142,5 +142,5 @@ namespace variance_result = variance1.get_variance(); CHECK_CLOSE(9.17, variance_result, 0.1); } - }; + } } diff --git a/test/test_variant_legacy.cpp b/test/test_variant_legacy.cpp index 73c26ef7..e0f8e2f2 100644 --- a/test/test_variant_legacy.cpp +++ b/test/test_variant_legacy.cpp @@ -961,7 +961,7 @@ namespace type = etl::legacy::visit(visitor, variant_const); CHECK_EQUAL(70, type); } - }; + } } #include "etl/private/diagnostic_pop.h" \ No newline at end of file diff --git a/test/test_variant_pool.cpp b/test/test_variant_pool.cpp index a2202709..ece9796c 100644 --- a/test/test_variant_pool.cpp +++ b/test/test_variant_pool.cpp @@ -310,5 +310,5 @@ namespace p = variant_pool2.create(); CHECK_THROW(variant_pool1.destroy(p), etl::pool_object_not_in_pool); } - }; + } } diff --git a/test/test_variant_pool_external_buffer.cpp b/test/test_variant_pool_external_buffer.cpp index 4756d884..411680ac 100644 --- a/test/test_variant_pool_external_buffer.cpp +++ b/test/test_variant_pool_external_buffer.cpp @@ -325,5 +325,5 @@ namespace delete[] buffer1; delete[] buffer2; } - }; + } } diff --git a/test/test_variant_variadic.cpp b/test/test_variant_variadic.cpp index 74518be9..dc8373ac 100644 --- a/test/test_variant_variadic.cpp +++ b/test/test_variant_variadic.cpp @@ -2138,7 +2138,7 @@ namespace CHECK_TRUE(variant1.is_supported_type()); CHECK_FALSE(variant1.is_supported_type()); } - }; + } } #include "etl/private/diagnostic_pop.h" diff --git a/test/test_vector.cpp b/test/test_vector.cpp index f7df1aaf..03f6a615 100644 --- a/test/test_vector.cpp +++ b/test/test_vector.cpp @@ -1620,5 +1620,5 @@ namespace CHECK(std::equal(blank_data.begin(), blank_data.end(), data.begin())); } - }; + } } diff --git a/test/test_vector_external_buffer.cpp b/test/test_vector_external_buffer.cpp index a8b0c07b..912ebc29 100644 --- a/test/test_vector_external_buffer.cpp +++ b/test/test_vector_external_buffer.cpp @@ -1320,5 +1320,5 @@ namespace CHECK_EQUAL(raw[4].i, dest[6].i); CHECK_EQUAL(raw[5].i, dest[7].i); } - }; + } } diff --git a/test/test_vector_non_trivial.cpp b/test/test_vector_non_trivial.cpp index 413ca3cd..aabd0e4a 100644 --- a/test/test_vector_non_trivial.cpp +++ b/test/test_vector_non_trivial.cpp @@ -1407,5 +1407,5 @@ namespace const DataNDC initial2(initial_data.begin(), initial_data.end()); CHECK((initial >= initial2) == (initial_data >= initial_data)); } - }; + } } diff --git a/test/test_vector_pointer.cpp b/test/test_vector_pointer.cpp index aa41eac0..ee6ce915 100644 --- a/test/test_vector_pointer.cpp +++ b/test/test_vector_pointer.cpp @@ -2199,5 +2199,5 @@ namespace CHECK_EQUAL(9, *data[9]); } #endif - }; + } } diff --git a/test/test_vector_pointer_external_buffer.cpp b/test/test_vector_pointer_external_buffer.cpp index 330801d8..e6be4831 100644 --- a/test/test_vector_pointer_external_buffer.cpp +++ b/test/test_vector_pointer_external_buffer.cpp @@ -2013,5 +2013,5 @@ namespace CHECK(i1 == *i2); CHECK(&i1 == i2); } - }; + } } diff --git a/test/test_xor_checksum.cpp b/test/test_xor_checksum.cpp index eb2e450e..95eac2fd 100644 --- a/test/test_xor_checksum.cpp +++ b/test/test_xor_checksum.cpp @@ -144,6 +144,6 @@ namespace CHECK_EQUAL(hash1, hash2); CHECK_EQUAL(hash1, hash3); } - }; + } } diff --git a/test/test_xor_rotate_checksum.cpp b/test/test_xor_rotate_checksum.cpp index 94fd886f..db9a8a12 100644 --- a/test/test_xor_rotate_checksum.cpp +++ b/test/test_xor_rotate_checksum.cpp @@ -153,6 +153,6 @@ namespace CHECK_EQUAL(hash1, hash2); CHECK_EQUAL(hash1, hash3); } - }; + } } diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters index af36ac3b..1af8495a 100644 --- a/test/vs2022/etl.vcxproj.filters +++ b/test/vs2022/etl.vcxproj.filters @@ -3722,9 +3722,6 @@ Tests\Misc - - Tests - Tests\Syntax Checks\Source @@ -3737,6 +3734,9 @@ Tests\State Machines + + Tests\Callbacks & Delegates +