From a94d0ce9868fec1825bd2247c3d93b2510bce323 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 27 Jun 2025 09:22:31 +0100 Subject: [PATCH] Revert "Work in progress" This reverts commit 799280f615c4c46d68571e990926f2dd2fc3d64f. # Conflicts: # include/etl/const_map.h # test/test_const_map.cpp --- include/etl/const_map.h | 666 ----------------- test/test_const_map.cpp | 1553 --------------------------------------- 2 files changed, 2219 deletions(-) delete mode 100644 include/etl/const_map.h delete mode 100644 test/test_const_map.cpp diff --git a/include/etl/const_map.h b/include/etl/const_map.h deleted file mode 100644 index af9905f7..00000000 --- a/include/etl/const_map.h +++ /dev/null @@ -1,666 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2025 John Wellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_CONST_MAP_INCLUDED -#define ETL_CONST_MAP_INCLUDED - -#include "platform.h" - -#if ETL_NOT_USING_CPP11 - #error NOT SUPPORTED FOR C++03 OR BELOW -#endif - -#include "algorithm.h" -#include "type_traits.h" -#include "functional.h" -#include "nth_type.h" -#include "span.h" - -#include "private/comparator_is_transparent.h" - -///\defgroup const_map const_map -///\ingroup containers - -namespace etl -{ - template - class iconst_map - { - public: - - using key_type = TKey; - using value_type = ETL_OR_STD::pair; - using mapped_type = TMapped ; - using key_compare = TKeyCompare; - using const_reference = const value_type&; - using const_pointer = const value_type*; - using const_iterator = const value_type*; - using size_type = size_t; - - /// Defines the parameter types - using const_key_reference = const key_type&; - using const_mapped_reference = const mapped_type&; - - //********************************************************************* - /// How to compare elements and keys. - //********************************************************************* - class value_compare - { - public: - - // Compare two value types. - ETL_CONSTEXPR14 bool operator ()(const value_type& element1, const value_type& element2) const ETL_NOEXCEPT - { - return kcompare(element1.first, element2.first); - } - - // Compare value type and key. - ETL_CONSTEXPR14 bool operator ()(const value_type& element, const_key_reference key) const ETL_NOEXCEPT - { - return kcompare(element.first, key); - } - - // Compare value types and key. - // Enabled for transparent comparators. - template ::value, int> = 0> - ETL_CONSTEXPR14 bool operator ()(const value_type& element, const K& key) const ETL_NOEXCEPT - { - return kcompare(element.first, key); - } - - // Compare key and value type. - ETL_CONSTEXPR14 bool operator ()(const_key_reference key, const value_type& element) const ETL_NOEXCEPT - { - return kcompare(key, element.first); - } - - // Compare key and value type. - // Enabled for transparent comparators. - template ::value, int> = 0> - ETL_CONSTEXPR14 bool operator ()(const K& key, const value_type& element) const ETL_NOEXCEPT - { - return kcompare(key, element.first); - } - - key_compare kcompare; - }; - - //************************************************************************* - /// Check that the elements are valid for a map. - /// The elements must be sorted and contain no duplicates. - /// \return true if the elements are valid for the map. - //************************************************************************* - ETL_CONSTEXPR14 bool is_valid() const ETL_NOEXCEPT - { - return etl::is_unique_sorted(begin(), end(), vcompare); - } - - //************************************************************************* - ///\brief Returns a const_iterator to the beginning of the map. - //************************************************************************* - ETL_CONSTEXPR14 const_iterator begin() const ETL_NOEXCEPT - { - return element_list; - } - - //************************************************************************* - ///\brief Returns a const_iterator to the beginning of the map. - //************************************************************************* - ETL_CONSTEXPR14 const_iterator cbegin() const ETL_NOEXCEPT - { - return element_list; - } - - //************************************************************************* - ///\brief Returns a const_iterator to the end of the map. - //************************************************************************* - ETL_CONSTEXPR14 const_iterator end() const ETL_NOEXCEPT - { - return element_list_end; - } - - //************************************************************************* - ///\brief Returns a const_iterator to the end of the map. - //************************************************************************* - ETL_CONSTEXPR14 const_iterator cend() const ETL_NOEXCEPT - { - return element_list_end; - } - - //************************************************************************* - ///\brief Returns a const_pointer to the beginning of the map. - //************************************************************************* - ETL_CONSTEXPR14 const_pointer data() const ETL_NOEXCEPT - { - return element_list; - } - - //************************************************************************* - ///\brief Index operator. - ///\param key The key of the element to return. - ///\return A const_mapped_reference to the mapped value at the index. - /// Undefined behaviour if the key is not in the map. - //************************************************************************* - ETL_CONSTEXPR14 const_mapped_reference operator[](const_key_reference key) const ETL_NOEXCEPT - { - const_iterator itr = find(key); - - return itr->second; - } - - //************************************************************************* - ///\brief Key index operator. - /// Enabled for transparent comparators. - ///\param key The key of the element to return. - ///\return A const_mapped_reference to the mapped value at the key index. - /// Undefined behaviour if the key is not in the map. - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 const_mapped_reference operator[](const K& key) const ETL_NOEXCEPT - { - const_iterator itr = find(key); - - return itr->second; - } - - //************************************************************************* - ///\brief Gets the mapped value at the key index. - ///\param key The key of the element to return. - ///\return A const_mapped_reference to the mapped value at the index. - /// Undefined behaviour if the key is not in the map. - //************************************************************************* - ETL_CONSTEXPR14 const_mapped_reference at(const_key_reference key) const ETL_NOEXCEPT - { - const_iterator itr = find(key); - - return itr->second; - } - - //************************************************************************* - ///\brief Gets the mapped value at the key index. - /// Enabled if the comparator is transparent. - ///\param key The key of the element to return. - ///\return A const_mapped_reference to the mapped value at the index. - /// Undefined behaviour if the key is not in the map. - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 const_mapped_reference at(const K& key) const ETL_NOEXCEPT - { - const_iterator itr = find(key); - - return itr->second; - } - - //************************************************************************* - ///\brief Gets a const_iterator to the mapped value at the key index. - ///\param key The key of the element to find. - ///\return A const_iterator to the mapped value at the index, - /// or end() if not found. - //************************************************************************* - ETL_CONSTEXPR14 const_iterator find(const_key_reference key) const ETL_NOEXCEPT - { - const_iterator itr = lower_bound(key); - - if ((itr != end()) && (keys_are_equal(itr->first, key))) - { - return itr; - } - - return end(); - - } - - //************************************************************************* - ///\brief Gets a const_iterator to the mapped value at the key index. - /// Enabled if the comparator is transparent. - ///\param key The key of the element to find. - ///\return A const_iterator to the mapped value at the index, - /// or end() if not found. - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 const_iterator find(const K& key) const ETL_NOEXCEPT - { - const_iterator itr = lower_bound(key); - - if ((itr != end()) && (keys_are_equal(itr->first, key))) - { - return itr; - } - - return end(); - } - - //************************************************************************* - ///\brief Checks if the map contains an element with key. - ///\param key The key of the element to check. - ///\return true if the map contains an element with key. - //************************************************************************* - ETL_CONSTEXPR14 bool contains(const_key_reference key) const ETL_NOEXCEPT - { - return find(key) != end(); - } - - //************************************************************************* - ///\brief Checks if the map contains an element with key. - /// Enabled if the comparator is transparent. - ///\param key The key of the element to check. - ///\return true if the map contains an element with key. - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 bool contains(const K& key) const ETL_NOEXCEPT - { - return find(key) != end(); - } - - //************************************************************************* - ///\brief Counts the numbeer elements with key. - ///\param key The key of the element to count. - ///\return 0 or 1 - //************************************************************************* - ETL_CONSTEXPR14 size_type count(const_key_reference key) const ETL_NOEXCEPT - { - return contains(key) ? 1 : 0; - } - - //************************************************************************* - ///\brief Counts the numbeer elements with key. - /// Enabled if the comparator is transparent. - ///\param key The key of the element to count. - ///\return 0 or 1 - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 size_type count(const K& key) const ETL_NOEXCEPT - { - return contains(key) ? 1 : 0; - } - - //************************************************************************* - ///\brief Returns a range containing all elements with the key. - /// The range is defined by a pair of two iterators, one to the - /// first element that is not less than the key and second to the first - /// element greater than the key. - ///\param key The key of the element - ///\return etl::pair or std::pair containing a pair of iterators. - //************************************************************************* - ETL_CONSTEXPR14 ETL_OR_STD::pair equal_range(const_key_reference key) const ETL_NOEXCEPT - { - return etl::equal_range(begin(), end(), key, vcompare); - } - - //************************************************************************* - ///\brief Returns a range containing all elements with the key. - /// The range is defined by a pair of two iterators, one to the - /// first element that is not less than the key and second to the first - /// element greater than the key. - /// Enabled if the comparator is transparent. - ///\param key The key of the element - ///\return etl::pair or std::pair containing a pair of iterators. - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 ETL_OR_STD::pair equal_range(const K& key) const ETL_NOEXCEPT - { - return etl::equal_range(begin(), end(), key, vcompare); - } - - //************************************************************************* - ///\brief Returns a const_iterator to the first element that is not less than the key. - /// Returns a const_iterator to the first element that is not less than the key. - ///\param key The key of the element - ///\return const_iterator to the element or end() - //************************************************************************* - ETL_CONSTEXPR14 const_iterator lower_bound(const_key_reference key) const ETL_NOEXCEPT - { - return etl::lower_bound(begin(), end(), key, vcompare); - } - - //************************************************************************* - ///\brief Returns a const_iterator to the first element that is not less than the key. - /// Returns a const_iterator to the first element that is not less than the key. - /// Enabled if the comparator is transparent. - ///\param key The key of the element - ///\return const_iterator to the element or end() - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 const_iterator lower_bound(const K& key) const ETL_NOEXCEPT - { - return etl::lower_bound(begin(), end(), key, vcompare); - } - - //************************************************************************* - ///\brief Returns a const_iterator to the first element that is greater than the key. - /// Returns a const_iterator to the first element that is greater than the key. - ///\param key The key of the element - ///\return const_iterator to the element or end() - //************************************************************************* - ETL_CONSTEXPR14 const_iterator upper_bound(const_key_reference key) const ETL_NOEXCEPT - { - return etl::upper_bound(begin(), end(), key, vcompare); - } - - //************************************************************************* - ///\brief Returns a const_iterator to the first element that is greater than the key. - /// Returns a const_iterator to the first element that is greater than the key. - /// Enabled if the comparator is transparent. - ///\param key The key of the element - ///\return const_iterator to the element or end() - //************************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 const_iterator upper_bound(const K& key) const ETL_NOEXCEPT - { - return etl::upper_bound(begin(), end(), key, vcompare); - } - - //************************************************************************* - /// Checks if the map is empty. - ///\return true if the map is empty. - //************************************************************************* - ETL_CONSTEXPR14 size_type empty() const ETL_NOEXCEPT - { - return size() == 0U; - } - - //************************************************************************* - /// Checks if the map is full. - ///\return true if the map is full. - //************************************************************************* - ETL_CONSTEXPR14 size_type full() const ETL_NOEXCEPT - { - return (max_elements != 0) && (size() == max_elements); - } - - //************************************************************************* - /// Gets the size of the map. - ///\return The size of the map. - //************************************************************************* - ETL_CONSTEXPR14 size_type size() const ETL_NOEXCEPT - { - return size_type(element_list_end - element_list); - } - - //************************************************************************* - /// Gets the maximum size of the map. - ///\return The maximum size of the map. - //************************************************************************* - ETL_CONSTEXPR14 size_type max_size() const ETL_NOEXCEPT - { - return max_elements; - } - - //************************************************************************* - /// Gets the capacity of the map. - /// This is always equal to max_size(). - ///\return The capacity of the map. - //************************************************************************* - ETL_CONSTEXPR14 size_type capacity() const ETL_NOEXCEPT - { - return max_elements; - } - - //************************************************************************* - /// How to compare two key elements. - ///\return An instance of the key_compare type. - //************************************************************************* - ETL_CONSTEXPR14 key_compare key_comp() const ETL_NOEXCEPT - { - return vcompare.kcompare; - } - - //************************************************************************* - /// How to compare two value elements. - ///\return An instance of the value_compare type. - //************************************************************************* - ETL_CONSTEXPR14 value_compare value_comp() const ETL_NOEXCEPT - { - return vcompare; - } - - protected: - - //************************************************************************* - /// Constructor - //************************************************************************* - template - ETL_CONSTEXPR14 explicit iconst_map(const value_type* element_list_, size_type size_, size_type max_elements_) ETL_NOEXCEPT - : element_list(element_list_) - , element_list_end{element_list_ + size_} - , max_elements(max_elements_) - { - } - - private: - - //********************************************************************* - /// Check to see if the keys are equal. - //********************************************************************* - ETL_CONSTEXPR14 bool keys_are_equal(const_key_reference key1, const_key_reference key2) const ETL_NOEXCEPT - { - return !key_compare()(key1, key2) && !key_compare()(key2, key1); - } - - //********************************************************************* - /// Check to see if the keys are equal. - /// Enabled if the comparator is transparent. - //********************************************************************* - template ::value, int> = 0> - ETL_CONSTEXPR14 bool keys_are_equal(const K1& key1, const K2& key2) const ETL_NOEXCEPT - { - return !key_compare()(key1, key2) && !key_compare()(key2, key1); - } - - value_compare vcompare; - - const value_type* element_list; - const value_type* element_list_end; - size_type max_elements; - }; - - //********************************************************************* - /// Map type designed for constexpr. - //********************************************************************* - template > - class const_map : public iconst_map - { - public: - - using base_t = iconst_map; - - using key_type = typename base_t::key_type; - using value_type = typename base_t::value_type; - using mapped_type = typename base_t::mapped_type ; - using key_compare = typename base_t::key_compare; - using const_reference = typename base_t::const_reference; - using const_pointer = typename base_t::const_pointer; - using const_iterator = typename base_t::const_iterator; - using size_type = typename base_t::size_type; - - /// Defines the parameter types - using const_key_reference = const key_type&; - using const_mapped_reference = const mapped_type&; - - static_assert((etl::is_default_constructible::value), "key_type must be default constructible"); - static_assert((etl::is_default_constructible::value), "mapped_type must be default constructible"); - - //************************************************************************* - ///\brief Construct a const_map from a variadic list of elements. - /// Static asserts if the elements are not of type value_type. - /// Static asserts if the number of elements is greater than the capacity of the const_map. - //************************************************************************* - template - ETL_CONSTEXPR14 explicit const_map(TElements&&... elements) ETL_NOEXCEPT - : iconst_map(element_list, sizeof...(elements), Size) - , element_list{etl::forward(elements)...} - { - static_assert((etl::are_all_same...>::value), "All elements must be value_type"); - static_assert(sizeof...(elements) <= Size, "Number of elements exceeds capacity"); - } - - private: - - value_type element_list[Size]; - }; - - //************************************************************************* - /// Template deduction guides. - //************************************************************************* -#if ETL_USING_CPP17 - template - const_map(TElements...) -> const_map::first_type, - typename etl::nth_type_t<0, TElements...>::second_type, - sizeof...(TElements)>; -#endif - - //********************************************************************* - /// Map type designed for constexpr. - //********************************************************************* - template > - class const_map_ext : public iconst_map - { - public: - - using base_t = iconst_map; - - using key_type = typename base_t::key_type; - using value_type = typename base_t::value_type; - using mapped_type = typename base_t::mapped_type ; - using key_compare = typename base_t::key_compare; - using const_reference = typename base_t::const_reference; - using const_pointer = typename base_t::const_pointer; - using const_iterator = typename base_t::const_iterator; - using size_type = typename base_t::size_type; - - /// Defines the parameter types - using const_key_reference = const key_type&; - using const_mapped_reference = const mapped_type&; - - static_assert((etl::is_default_constructible::value), "key_type must be default constructible"); - static_assert((etl::is_default_constructible::value), "mapped_type must be default constructible"); - - //************************************************************************* - ///\brief Default construct a const_map. - //************************************************************************* - ETL_CONSTEXPR14 const_map_ext() ETL_NOEXCEPT - : iconst_map(nullptr, 0, 0) - { - } - - //************************************************************************* - ///\brief Construct a const_map from a variadic list of elements. - //************************************************************************* - template - ETL_CONSTEXPR14 explicit const_map_ext(const etl::span& sp) ETL_NOEXCEPT - : iconst_map(sp.data(), Size, Size) - { - } - - //************************************************************************* - ///\brief Construct a const_map from an array. - //************************************************************************* - template - ETL_CONSTEXPR14 explicit const_map_ext(const value_type(&begin_)[Size]) ETL_NOEXCEPT - : iconst_map(begin_, Size, Size) - { - } - }; - - //************************************************************************* - /// Template deduction guides. - //************************************************************************* -#if ETL_USING_CPP17 - template - const_map_ext(const etl::span&) -> const_map_ext; - - template - const_map_ext(const TElements(&)[N]) -> const_map_ext; -#endif - - //************************************************************************* - /// Equality test. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator ==(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return etl::equal(lhs.begin(), lhs.end(), rhs.begin()); - } - - //************************************************************************* - /// Inequality test. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator !=(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return !(lhs == rhs); - } - - //************************************************************************* - /// Less-than. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator <(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return etl::lexicographical_compare(lhs.begin(), lhs.end(), - rhs.begin(), rhs.end(), - lhs.value_comp()); - } - - //************************************************************************* - /// Greater-than. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator >(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return (rhs < lhs); - } - - //************************************************************************* - /// Less-than-equal. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator <=(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return !(rhs < lhs); - } - - //************************************************************************* - /// Greater-than-equal. - //************************************************************************* - template - ETL_CONSTEXPR14 bool operator >=(const etl::iconst_map& lhs, - const etl::iconst_map& rhs) ETL_NOEXCEPT - { - return !(lhs < rhs); - } -} - -#endif diff --git a/test/test_const_map.cpp b/test/test_const_map.cpp deleted file mode 100644 index 19fb9980..00000000 --- a/test/test_const_map.cpp +++ /dev/null @@ -1,1553 +0,0 @@ -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2025 John Wellbelove, rlindeman - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the 'Software'), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#include "unit_test_framework.h" - -#include -#include -#include -#include -#include -#include -#include - -#include "etl/const_map.h" -#include "etl/map.h" -#include "etl/string.h" - -#include "data.h" - -namespace -{ - static const size_t Max_Size = 10UL; - - //************************************************************************* - // The key type - //************************************************************************* - struct Key - { - // Default constructor - constexpr Key() - : k(0) - { - } - - // Construct from char key - constexpr explicit Key(char k_) - : k(k_) - { - } - - char k; - }; - - // Less-than operator for Key < Key - constexpr bool operator <(const Key& lhs, const Key& rhs) noexcept - { - return (lhs.k < rhs.k); - } - - // Less-than operator for Key < char - constexpr bool operator <(const Key& lhs, char rhs) noexcept - { - return (lhs.k < rhs); - } - - // Less-than operator for char < Key - constexpr bool operator <(char lhs, const Key& rhs) noexcept - { - return (lhs < rhs.k); - } - - // Greater-than operator for char > Key - constexpr bool operator ==(const Key& lhs, const Key& rhs) noexcept - { - return (lhs.k == rhs.k); - } - - #define TEST_GREATER_THAN - #ifdef TEST_GREATER_THAN - using Data = etl::const_map>; - using IData = etl::iconst_map>; - using DataTransparentComparator = etl::const_map>; - using IDataTransparentComparator = etl::iconst_map>; - #else - using Data = etl::const_map>; - using IData = etl::iconst_map>; - using DataTransparentComparator = etl::const_map>; - using IDataTransparentComparator = etl::iconst_map>; - #endif - - using value_type = Data::value_type; - using key_type = Data::key_type; - using mapped_type = Data::mapped_type; - using const_iterator = Data::const_iterator; - - SUITE(test_const_map) - { - //************************************************************************* - TEST(test_default_constructor) - { - static const Data data; - - static const bool is_valid = data.is_valid(); - static const size_t size = data.size(); - static const bool empty = data.empty(); - static const bool full = data.full(); - static const size_t capacity = data.capacity(); - static const size_t max_size = data.max_size(); - static const const_iterator begin = data.begin(); - static const const_iterator end = data.end(); - - CHECK_TRUE(is_valid); - CHECK_TRUE(size == 0UL); - CHECK_TRUE(empty); - CHECK_FALSE(full); - CHECK_TRUE(capacity == Max_Size); - CHECK_TRUE(max_size == Max_Size); - CHECK_TRUE(begin == end); - } - - //************************************************************************* - TEST(test_constructor_min_size) - { - static const Data data{ value_type{Key('A'), 0 } }; - - static const bool is_valid = data.is_valid(); - static const size_t size = data.size(); - static const bool empty = data.empty(); - static const bool full = data.full(); - static const size_t capacity = data.capacity(); - static const size_t max_size = data.max_size(); - static const const_iterator begin = data.begin(); - static const const_iterator end = data.end(); - - CHECK_TRUE(is_valid); - CHECK_TRUE(size == 1U); - CHECK_FALSE(empty); - CHECK_FALSE(full); - CHECK_TRUE(capacity == Max_Size); - CHECK_TRUE(max_size == Max_Size); - CHECK_FALSE(begin == end); - } - - //************************************************************************* - TEST(test_constructor_max_size) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const bool is_valid = data.is_valid(); - static const size_t size = data.size(); - static const bool empty = data.empty(); - static const bool full = data.full(); - static const size_t capacity = data.capacity(); - static const size_t max_size = data.max_size(); - static const const_iterator begin = data.begin(); - static const const_iterator end = data.end(); - - CHECK_TRUE(is_valid); - CHECK_TRUE(size == Max_Size); - CHECK_FALSE(empty); - CHECK_TRUE(full); - CHECK_TRUE(capacity == Max_Size); - CHECK_TRUE(max_size == Max_Size); - CHECK_FALSE(begin == end); - } - - //************************************************************************* - TEST(test_constructor_max_size_status_from_iconst_map) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const IData& idata = data; - - static const bool is_valid = idata.is_valid(); - static const size_t size = idata.size(); - static const bool empty = idata.empty(); - static const bool full = idata.full(); - static const size_t capacity = idata.capacity(); - static const size_t max_size = idata.max_size(); - static const const_iterator begin = idata.begin(); - static const const_iterator end = idata.end(); - - CHECK_TRUE(is_valid); - CHECK_TRUE(size == Max_Size); - CHECK_FALSE(empty); - CHECK_TRUE(full); - CHECK_TRUE(capacity == Max_Size); - CHECK_TRUE(max_size == Max_Size); - CHECK_FALSE(begin == end); - } - - ////************************************************************************* - // Enable to check static_assert "Number of elements exceeds capacity" - ////************************************************************************* - //TEST(test_constructor_excess_size) - //{ - // static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - // value_type{Key('F'), 5 }, value_type{'G'), 6 }, value_type{'H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, - // value_type{Key('K'), 10 } }; - //} - -#if ETL_USING_CPP17 - //************************************************************************* - TEST(test_cpp17_deduced_constructor) - { - static const etl::const_map data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - etl::const_map check{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - CHECK_TRUE(data.is_valid()); - CHECK_TRUE(data.size() == Max_Size); - CHECK_FALSE(data.empty()); - CHECK_TRUE(data.full()); - CHECK_TRUE(data.capacity() == Max_Size); - CHECK_TRUE(data.max_size() == Max_Size); - CHECK_FALSE(data.begin() == data.end()); - } -#endif - - //************************************************************************* - TEST(test_begin) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - CHECK_TRUE(data.is_valid()); - static const auto value = *data.begin(); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE((value_type{ Key('J'), 9 }) == value); -#else - CHECK_TRUE((value_type{ Key('A'), 0 }) == value); -#endif - } - - //************************************************************************* - TEST(test_end_const) - { - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const const_iterator end_itr = data.end(); - - CHECK_TRUE(end_itr == (data.begin() + data.size())); - } - - //************************************************************************* - TEST(test_index) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const mapped_type atA = data[Key('A')]; - static const mapped_type atB = data[Key('B')]; - static const mapped_type atC = data[Key('C')]; - static const mapped_type atD = data[Key('D')]; - static const mapped_type atE = data[Key('E')]; - static const mapped_type atF = data[Key('F')]; - static const mapped_type atG = data[Key('G')]; - static const mapped_type atH = data[Key('H')]; - static const mapped_type atI = data[Key('I')]; - static const mapped_type atJ = data[Key('J')]; - - CHECK_TRUE(data.is_valid()); - CHECK(atA == 0); - CHECK(atB == 1); - CHECK(atC == 2); - CHECK(atD == 3); - CHECK(atE == 4); - CHECK(atF == 5); - CHECK(atG == 6); - CHECK(atH == 7); - CHECK(atI == 8); - CHECK(atJ == 9); - } - - //************************************************************************* - TEST(test_index_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const mapped_type atA = data['A']; - static const mapped_type atB = data['B']; - static const mapped_type atC = data['C']; - static const mapped_type atD = data['D']; - static const mapped_type atE = data['E']; - static const mapped_type atF = data['F']; - static const mapped_type atG = data['G']; - static const mapped_type atH = data['H']; - static const mapped_type atI = data['I']; - static const mapped_type atJ = data['J']; - - CHECK_TRUE(data.is_valid()); - CHECK(atA == 0); - CHECK(atB == 1); - CHECK(atC == 2); - CHECK(atD == 3); - CHECK(atE == 4); - CHECK(atF == 5); - CHECK(atG == 6); - CHECK(atH == 7); - CHECK(atI == 8); - CHECK(atJ == 9); - } - - //************************************************************************* - TEST(test_at) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const mapped_type atA = data.at(Key('A')); - static const mapped_type atB = data.at(Key('B')); - static const mapped_type atC = data.at(Key('C')); - static const mapped_type atD = data.at(Key('D')); - static const mapped_type atE = data.at(Key('E')); - static const mapped_type atF = data.at(Key('F')); - static const mapped_type atG = data.at(Key('G')); - static const mapped_type atH = data.at(Key('H')); - static const mapped_type atI = data.at(Key('I')); - static const mapped_type atJ = data.at(Key('J')); - - CHECK_TRUE(data.is_valid()); - CHECK(atA == 0); - CHECK(atB == 1); - CHECK(atC == 2); - CHECK(atD == 3); - CHECK(atE == 4); - CHECK(atF == 5); - CHECK(atG == 6); - CHECK(atH == 7); - CHECK(atI == 8); - CHECK(atJ == 9); - } - - //************************************************************************* - TEST(test_at_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const mapped_type atA = data.at('A'); - static const mapped_type atB = data.at('B'); - static const mapped_type atC = data.at('C'); - static const mapped_type atD = data.at('D'); - static const mapped_type atE = data.at('E'); - static const mapped_type atF = data.at('F'); - static const mapped_type atG = data.at('G'); - static const mapped_type atH = data.at('H'); - static const mapped_type atI = data.at('I'); - static const mapped_type atJ = data.at('J'); - - CHECK_TRUE(data.is_valid()); - CHECK(atA == 0); - CHECK(atB == 1); - CHECK(atC == 2); - CHECK(atD == 3); - CHECK(atE == 4); - CHECK(atF == 5); - CHECK(atG == 6); - CHECK(atH == 7); - CHECK(atI == 8); - CHECK(atJ == 9); - } - - //************************************************************************* - TEST(test_equal_range) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const ETL_OR_STD::pair resultA = data.equal_range(Key('A')); - static const ETL_OR_STD::pair resultB = data.equal_range(Key('B')); - static const ETL_OR_STD::pair resultC = data.equal_range(Key('C')); - static const ETL_OR_STD::pair resultD = data.equal_range(Key('D')); - static const ETL_OR_STD::pair resultE = data.equal_range(Key('E')); - static const ETL_OR_STD::pair resultF = data.equal_range(Key('F')); - static const ETL_OR_STD::pair resultG = data.equal_range(Key('G')); - static const ETL_OR_STD::pair resultH = data.equal_range(Key('H')); - static const ETL_OR_STD::pair resultI = data.equal_range(Key('I')); - static const ETL_OR_STD::pair resultJ = data.equal_range(Key('J')); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA.first))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB.first))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC.first))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultD.first))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE.first))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF.first))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultG.first))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultH.first))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultI.first))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultJ.first))); - - CHECK_EQUAL(10, (std::distance(data.begin(), resultA.second))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultB.second))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultC.second))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD.second))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultE.second))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF.second))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultG.second))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultH.second))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultI.second))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultJ.second))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA.first))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB.first))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC.first))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD.first))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE.first))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF.first))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG.first))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH.first))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI.first))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ.first))); - - CHECK_EQUAL(1, (std::distance(data.begin(), resultA.second))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultB.second))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultC.second))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultD.second))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE.second))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultF.second))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultG.second))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultH.second))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultI.second))); - CHECK_EQUAL(10, (std::distance(data.begin(), resultJ.second))); -#endif - } - - //************************************************************************* - TEST(test_equal_range_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const ETL_OR_STD::pair resultA = data.equal_range('A'); - static const ETL_OR_STD::pair resultB = data.equal_range('B'); - static const ETL_OR_STD::pair resultC = data.equal_range('C'); - static const ETL_OR_STD::pair resultD = data.equal_range('D'); - static const ETL_OR_STD::pair resultE = data.equal_range('E'); - static const ETL_OR_STD::pair resultF = data.equal_range('F'); - static const ETL_OR_STD::pair resultG = data.equal_range('G'); - static const ETL_OR_STD::pair resultH = data.equal_range('H'); - static const ETL_OR_STD::pair resultI = data.equal_range('I'); - static const ETL_OR_STD::pair resultJ = data.equal_range('J'); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA.first))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB.first))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC.first))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultD.first))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE.first))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF.first))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultG.first))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultH.first))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultI.first))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultJ.first))); - - CHECK_EQUAL(10, (std::distance(data.begin(), resultA.second))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultB.second))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultC.second))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD.second))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultE.second))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF.second))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultG.second))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultH.second))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultI.second))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultJ.second))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA.first))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB.first))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC.first))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD.first))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE.first))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF.first))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG.first))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH.first))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI.first))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ.first))); - - CHECK_EQUAL(1, (std::distance(data.begin(), resultA.second))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultB.second))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultC.second))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultD.second))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE.second))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultF.second))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultG.second))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultH.second))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultI.second))); - CHECK_EQUAL(10, (std::distance(data.begin(), resultJ.second))); -#endif - } - - //************************************************************************* - TEST(test_lower_bound) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('K'), 10 }, value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, - value_type{Key('F'), 5 }, value_type{Key('E'), 4 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('E'), 4 }, value_type{Key('F'), 5 }, - value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } }; -#endif - - static const const_iterator resultA = data.lower_bound(Key('A')); - static const const_iterator resultB = data.lower_bound(Key('B')); - static const const_iterator resultC = data.lower_bound(Key('C')); - static const const_iterator resultD = data.lower_bound(Key('D')); - static const const_iterator resultE = data.lower_bound(Key('E')); - static const const_iterator resultF = data.lower_bound(Key('F')); - static const const_iterator resultG = data.lower_bound(Key('G')); - static const const_iterator resultH = data.lower_bound(Key('H')); - static const const_iterator resultI = data.lower_bound(Key('I')); - static const const_iterator resultJ = data.lower_bound(Key('J')); - static const const_iterator resultK = data.lower_bound(Key('K')); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultK))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultK))); -#endif - } - - //************************************************************************* - TEST(test_lower_bound_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('K'), 10 }, value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, - value_type{Key('F'), 5 }, value_type{Key('E'), 4 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('E'), 4 }, value_type{Key('F'), 5 }, - value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } }; -#endif - - static const const_iterator resultA = data.lower_bound('A'); - static const const_iterator resultB = data.lower_bound('B'); - static const const_iterator resultC = data.lower_bound('C'); - static const const_iterator resultD = data.lower_bound('D'); - static const const_iterator resultE = data.lower_bound('E'); - static const const_iterator resultF = data.lower_bound('F'); - static const const_iterator resultG = data.lower_bound('G'); - static const const_iterator resultH = data.lower_bound('H'); - static const const_iterator resultI = data.lower_bound('I'); - static const const_iterator resultJ = data.lower_bound('J'); - static const const_iterator resultK = data.lower_bound('K'); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultK))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultK))); -#endif - } - - //************************************************************************* - TEST(test_upper_bound) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('K'), 10 }, value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, - value_type{Key('F'), 5 }, value_type{Key('E'), 4 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('E'), 4 }, value_type{Key('F'), 5 }, - value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } }; -#endif - - static const const_iterator resultA = data.upper_bound(Key('A')); - static const const_iterator resultB = data.upper_bound(Key('B')); - static const const_iterator resultC = data.upper_bound(Key('C')); - static const const_iterator resultD = data.upper_bound(Key('D')); - static const const_iterator resultE = data.upper_bound(Key('E')); - static const const_iterator resultF = data.upper_bound(Key('F')); - static const const_iterator resultG = data.upper_bound(Key('G')); - static const const_iterator resultH = data.upper_bound(Key('H')); - static const const_iterator resultI = data.upper_bound(Key('I')); - static const const_iterator resultJ = data.upper_bound(Key('J')); - static const const_iterator resultK = data.upper_bound(Key('K')); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(10, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultK))); -#else - CHECK_EQUAL(1, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(10, (std::distance(data.begin(), resultK))); -#endif - } - - //************************************************************************* - TEST(test_upper_bound_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('K'), 10 }, value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, - value_type{Key('F'), 5 }, value_type{Key('E'), 4 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('E'), 4 }, value_type{Key('F'), 5 }, - value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 }, value_type{Key('K'), 10 } }; -#endif - - static const const_iterator resultA = data.upper_bound('A'); - static const const_iterator resultB = data.upper_bound('B'); - static const const_iterator resultC = data.upper_bound('C'); - static const const_iterator resultD = data.upper_bound('D'); - static const const_iterator resultE = data.upper_bound('E'); - static const const_iterator resultF = data.upper_bound('F'); - static const const_iterator resultG = data.upper_bound('G'); - static const const_iterator resultH = data.upper_bound('H'); - static const const_iterator resultI = data.upper_bound('I'); - static const const_iterator resultJ = data.upper_bound('J'); - static const const_iterator resultK = data.upper_bound('K'); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(10, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultK))); -#else - CHECK_EQUAL(1, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ))); - CHECK_EQUAL(10, (std::distance(data.begin(), resultK))); -#endif - } - - //************************************************************************* - TEST(test_count) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const size_t countA = data.count(Key('A')); - static const size_t countB = data.count(Key('B')); - static const size_t countC = data.count(Key('C')); - static const size_t countD = data.count(Key('D')); - static const size_t countE = data.count(Key('E')); - static const size_t countF = data.count(Key('F')); - static const size_t countG = data.count(Key('G')); - static const size_t countH = data.count(Key('H')); - static const size_t countI = data.count(Key('I')); - static const size_t countJ = data.count(Key('J')); - static const size_t countK = data.count(Key('K')); - - CHECK_EQUAL(1, countA); - CHECK_EQUAL(1, countB); - CHECK_EQUAL(1, countC); - CHECK_EQUAL(1, countD); - CHECK_EQUAL(1, countE); - CHECK_EQUAL(1, countF); - CHECK_EQUAL(1, countG); - CHECK_EQUAL(1, countH); - CHECK_EQUAL(1, countI); - CHECK_EQUAL(1, countJ); - CHECK_EQUAL(0, countK); - } - - //************************************************************************* - TEST(test_count_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const size_t countA = data.count('A'); - static const size_t countB = data.count('B'); - static const size_t countC = data.count('C'); - static const size_t countD = data.count('D'); - static const size_t countE = data.count('E'); - static const size_t countF = data.count('F'); - static const size_t countG = data.count('G'); - static const size_t countH = data.count('H'); - static const size_t countI = data.count('I'); - static const size_t countJ = data.count('J'); - static const size_t countK = data.count('K'); - - CHECK_EQUAL(1, countA); - CHECK_EQUAL(1, countB); - CHECK_EQUAL(1, countC); - CHECK_EQUAL(1, countD); - CHECK_EQUAL(1, countE); - CHECK_EQUAL(1, countF); - CHECK_EQUAL(1, countG); - CHECK_EQUAL(1, countH); - CHECK_EQUAL(1, countI); - CHECK_EQUAL(1, countJ); - CHECK_EQUAL(0, countK); - } - - //************************************************************************* - TEST(test_const_iterator) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - const_iterator itr = data.begin(); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE((value_type{Key('J'), 9 }) == *itr++); - CHECK_TRUE((value_type{Key('I'), 8 }) == *itr++); - CHECK_TRUE((value_type{Key('H'), 7 }) == *itr++); - CHECK_TRUE((value_type{Key('G'), 6 }) == *itr++); - CHECK_TRUE((value_type{Key('F'), 5 }) == *itr++); - CHECK_TRUE((value_type{Key('E'), 4 }) == *itr++); - CHECK_TRUE((value_type{Key('D'), 3 }) == *itr++); - CHECK_TRUE((value_type{Key('C'), 2 }) == *itr++); - CHECK_TRUE((value_type{Key('B'), 1 }) == *itr++); - CHECK_TRUE((value_type{Key('A'), 0 }) == *itr++); - CHECK_TRUE(itr == data.end()); -#else - CHECK_TRUE((value_type{Key('A'), 0 }) == *itr++); - CHECK_TRUE((value_type{Key('B'), 1 }) == *itr++); - CHECK_TRUE((value_type{Key('C'), 2 }) == *itr++); - CHECK_TRUE((value_type{Key('D'), 3 }) == *itr++); - CHECK_TRUE((value_type{Key('E'), 4 }) == *itr++); - CHECK_TRUE((value_type{Key('F'), 5 }) == *itr++); - CHECK_TRUE((value_type{Key('G'), 6 }) == *itr++); - CHECK_TRUE((value_type{Key('H'), 7 }) == *itr++); - CHECK_TRUE((value_type{Key('I'), 8 }) == *itr++); - CHECK_TRUE((value_type{Key('J'), 9 }) == *itr++); - CHECK_TRUE(itr == data.end()); -#endif - } - - //************************************************************************* - TEST(test_find) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const const_iterator resultA = data.find(Key('A')); - static const const_iterator resultB = data.find(Key('B')); - static const const_iterator resultC = data.find(Key('C')); - static const const_iterator resultD = data.find(Key('D')); - static const const_iterator resultE = data.find(Key('E')); - static const const_iterator resultF = data.find(Key('F')); - static const const_iterator resultG = data.find(Key('G')); - static const const_iterator resultH = data.find(Key('H')); - static const const_iterator resultI = data.find(Key('I')); - static const const_iterator resultJ = data.find(Key('J')); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultJ))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ))); -#endif - } - - //************************************************************************* - TEST(test_find_using_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const const_iterator resultA = data.find('A'); - static const const_iterator resultB = data.find('B'); - static const const_iterator resultC = data.find('C'); - static const const_iterator resultD = data.find('D'); - static const const_iterator resultE = data.find('E'); - static const const_iterator resultF = data.find('F'); - static const const_iterator resultG = data.find('G'); - static const const_iterator resultH = data.find('H'); - static const const_iterator resultI = data.find('I'); - static const const_iterator resultJ = data.find('J'); - -#ifdef TEST_GREATER_THAN - CHECK_EQUAL(9, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(0, (std::distance(data.begin(), resultJ))); -#else - CHECK_EQUAL(0, (std::distance(data.begin(), resultA))); - CHECK_EQUAL(1, (std::distance(data.begin(), resultB))); - CHECK_EQUAL(2, (std::distance(data.begin(), resultC))); - CHECK_EQUAL(3, (std::distance(data.begin(), resultD))); - CHECK_EQUAL(4, (std::distance(data.begin(), resultE))); - CHECK_EQUAL(5, (std::distance(data.begin(), resultF))); - CHECK_EQUAL(6, (std::distance(data.begin(), resultG))); - CHECK_EQUAL(7, (std::distance(data.begin(), resultH))); - CHECK_EQUAL(8, (std::distance(data.begin(), resultI))); - CHECK_EQUAL(9, (std::distance(data.begin(), resultJ))); -#endif - } - - //************************************************************************* - TEST(test_key_compare) - { - static const Data data; - - static const Data::key_compare compare = data.key_comp(); - - static const Data::key_type a(Key('A')); - static const Data::key_type b(Key('B')); - -#ifdef TEST_GREATER_THAN - CHECK(!compare(a, b)); - CHECK(compare(b, a)); -#else - CHECK(compare(a, b)); - CHECK(!compare(b, a)); -#endif - } - - //************************************************************************* - TEST(test_key_compare_using_transparent_comparator) - { - static const DataTransparentComparator data; - - static const DataTransparentComparator::key_compare compare = data.key_comp(); - - static const DataTransparentComparator::key_type a(Key('A')); - static const DataTransparentComparator::key_type b(Key('B')); - -#ifdef TEST_GREATER_THAN - CHECK(!compare(a, b)); - CHECK(compare(b, a)); -#else - CHECK(compare(a, b)); - CHECK(!compare(b, a)); -#endif - } - - //************************************************************************* - TEST(test_value_compare) - { - static const Data data; - - static const Data::value_compare compare = data.value_comp(); - - static const Data::value_type a(Key('A'), 0); - static const Data::value_type b(Key('B'), 1); - -#ifdef TEST_GREATER_THAN - CHECK(!compare(a, b)); - CHECK(compare(b, a)); -#else - CHECK(compare(a, b)); - CHECK(!compare(b, a)); -#endif - } - - //************************************************************************* - TEST(test_contains) - { -#ifdef TEST_GREATER_THAN - static const Data data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const Data data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const bool containsA = data.contains(Key('A')); - static const bool containsB = data.contains(Key('B')); - static const bool containsC = data.contains(Key('C')); - static const bool containsD = data.contains(Key('D')); - static const bool containsE = data.contains(Key('E')); - static const bool containsF = data.contains(Key('F')); - static const bool containsG = data.contains(Key('G')); - static const bool containsH = data.contains(Key('H')); - static const bool containsI = data.contains(Key('I')); - static const bool containsJ = data.contains(Key('J')); - static const bool containsK = data.contains(Key('K')); - - CHECK_TRUE(containsA); - CHECK_TRUE(containsB); - CHECK_TRUE(containsC); - CHECK_TRUE(containsD); - CHECK_TRUE(containsE); - CHECK_TRUE(containsF); - CHECK_TRUE(containsG); - CHECK_TRUE(containsH); - CHECK_TRUE(containsI); - CHECK_TRUE(containsJ); - CHECK_FALSE(containsK); - } - - //************************************************************************* - TEST(test_contains_with_transparent_comparator) - { -#ifdef TEST_GREATER_THAN - static const DataTransparentComparator data{ value_type{Key('J'), 9 }, value_type{Key('I'), 8 }, value_type{Key('H'), 7 }, value_type{Key('G'), 6 }, value_type{Key('F'), 5 }, - value_type{Key('E'), 4 }, value_type{Key('D'), 3 }, value_type{Key('C'), 2 }, value_type{Key('B'), 1 }, value_type{Key('A'), 0 } }; -#else - static const DataTransparentComparator data{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; -#endif - - static const bool containsA = data.contains('A'); - static const bool containsB = data.contains('B'); - static const bool containsC = data.contains('C'); - static const bool containsD = data.contains('D'); - static const bool containsE = data.contains('E'); - static const bool containsF = data.contains('F'); - static const bool containsG = data.contains('G'); - static const bool containsH = data.contains('H'); - static const bool containsI = data.contains('I'); - static const bool containsJ = data.contains('J'); - static const bool containsK = data.contains('K'); - - CHECK_TRUE(containsA); - CHECK_TRUE(containsB); - CHECK_TRUE(containsC); - CHECK_TRUE(containsD); - CHECK_TRUE(containsE); - CHECK_TRUE(containsF); - CHECK_TRUE(containsG); - CHECK_TRUE(containsH); - CHECK_TRUE(containsI); - CHECK_TRUE(containsJ); - CHECK_FALSE(containsK); - } - - //************************************************************************* - TEST(test_key_comp) - { - static const Data data; - static const Data::key_compare compare = data.key_comp(); - - static const bool compareAA = compare(Key{ 'A' }, Key{ 'A' }); - static const bool compareBA = compare(Key{ 'B' }, Key{ 'A' }); - static const bool compareAB = compare(Key{ 'A' }, Key{ 'B' }); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(compareAA); - CHECK_TRUE(compareBA); - CHECK_FALSE(compareAB); -#else - CHECK_FALSE(compareAA); - CHECK_FALSE(compareBA); - CHECK_TRUE(compareAB); -#endif - } - - //************************************************************************* - TEST(test_key_comp_transparent_comparator) - { - static const DataTransparentComparator data; - static const DataTransparentComparator::key_compare compare = data.key_comp(); - - static const bool compareAA = compare('A', 'A'); - static const bool compareBA = compare('B', 'A'); - static const bool compareAB = compare('A', 'B'); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(compareAA); - CHECK_TRUE(compareBA); - CHECK_FALSE(compareAB); -#else - CHECK_FALSE(compareAA); - CHECK_FALSE(compareBA); - CHECK_TRUE(compareAB); -#endif - } - - //************************************************************************* - TEST(test_value_comp) - { - static const Data data; - static const Data::value_compare compare = data.value_comp(); - - static const bool compareAA1 = compare(value_type{ Key{ 'A' }, 0 }, value_type{ Key{ 'A' }, 0 }); - static const bool compareAA2 = compare(value_type{ Key{ 'A' }, 0 }, Key{ 'A' }); - static const bool compareAA3 = compare(Key{ 'A' }, value_type{ Key{ 'A' }, 0 }); - - static const bool compareBA1 = compare(value_type{ Key{ 'B' }, 0 }, value_type{ Key{ 'A' }, 0 }); - static const bool compareBA2 = compare(value_type{ Key{ 'B' }, 0 }, Key{ 'A' }); - static const bool compareBA3 = compare(Key{ 'B' }, value_type{ Key{ 'A' }, 0 }); - - 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 });; - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(compareAA1); - CHECK_FALSE(compareAA2); - CHECK_FALSE(compareAA3); - - CHECK_TRUE(compareBA1); - CHECK_TRUE(compareBA2); - CHECK_TRUE(compareBA3); - - CHECK_FALSE(compareAB1); - CHECK_FALSE(compareAB2); - CHECK_FALSE(compareAB3); -#else - CHECK_FALSE(compareAA1); - CHECK_FALSE(compareAA2); - CHECK_FALSE(compareAA3); - - CHECK_FALSE(compareBA1); - CHECK_FALSE(compareBA2); - CHECK_FALSE(compareBA3); - - CHECK_TRUE(compareAB1); - CHECK_TRUE(compareAB2); - CHECK_TRUE(compareAB3); -#endif - } - - //************************************************************************* - TEST(test_value_comp_transparent_comparator) - { - static const DataTransparentComparator data; - static const DataTransparentComparator::value_compare compare = data.value_comp(); - - static const bool compareAA1 = compare(value_type{ 'A', 0 }, value_type{ 'A', 0 }); - static const bool compareAA2 = compare(value_type{ 'A', 0 }, 'A'); - static const bool compareAA3 = compare('A', value_type{ 'A', 0 }); - - static const bool compareBA1 = compare(value_type{ 'B', 0 }, value_type{ 'A', 0 }); - static const bool compareBA2 = compare(value_type{ 'B', 0 }, 'A'); - static const bool compareBA3 = compare('B', value_type{ 'A', 0 }); - - 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 });; - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(compareAA1); - CHECK_FALSE(compareAA2); - CHECK_FALSE(compareAA3); - - CHECK_TRUE(compareBA1); - CHECK_TRUE(compareBA2); - CHECK_TRUE(compareBA3); - - CHECK_FALSE(compareAB1); - CHECK_FALSE(compareAB2); - CHECK_FALSE(compareAB3); -#else - CHECK_FALSE(compareAA1); - CHECK_FALSE(compareAA2); - CHECK_FALSE(compareAA3); - - CHECK_FALSE(compareBA1); - CHECK_FALSE(compareBA2); - CHECK_FALSE(compareBA3); - - CHECK_TRUE(compareAB1); - CHECK_TRUE(compareAB2); - CHECK_TRUE(compareAB3); -#endif - } - - //************************************************************************* - TEST(test_equal) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool equal12 = (data1 == data2); - static const bool equal13 = (data1 == data3); - - CHECK_TRUE(equal12); - CHECK_FALSE(equal13); - } - - //************************************************************************* - TEST(test_equal_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool equal12 = (data1 == data2); - static const bool equal13 = (data1 == data3); - - CHECK_TRUE(equal12); - CHECK_FALSE(equal13); - } - - //************************************************************************* - TEST(test_not_equal) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool not_equal12 = (data1 != data2); - static const bool not_equal13 = (data1 != data3); - - CHECK_FALSE(not_equal12); - CHECK_TRUE(not_equal13); - } - - //************************************************************************* - TEST(test_not_equal_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 6 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool not_equal12 = (data1 != data2); - static const bool not_equal13 = (data1 != data3); - - CHECK_FALSE(not_equal12); - CHECK_TRUE(not_equal13); - } - - //************************************************************************* - TEST(test_less_than) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool less_than12 = (data1 < data2); - static const bool less_than23 = (data2 < data3); - static const bool less_than21 = (data2 < data1); - static const bool less_than32 = (data3 < data2); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(less_than12); - CHECK_FALSE(less_than23); - CHECK_TRUE(less_than21); - CHECK_TRUE(less_than32); -#else - CHECK_TRUE(less_than12); - CHECK_TRUE(less_than23); - CHECK_FALSE(less_than21); - CHECK_FALSE(less_than32); -#endif - } - - //************************************************************************* - TEST(test_less_than_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool less_than12 = (data1 < data2); - static const bool less_than23 = (data2 < data3); - static const bool less_than21 = (data2 < data1); - static const bool less_than32 = (data3 < data2); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(less_than12); - CHECK_FALSE(less_than23); - CHECK_TRUE(less_than21); - CHECK_TRUE(less_than32); -#else - CHECK_TRUE(less_than12); - CHECK_TRUE(less_than23); - CHECK_FALSE(less_than21); - CHECK_FALSE(less_than32); -#endif - } - - //************************************************************************* - TEST(test_less_than_equal) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool less_than_equal12 = (data1 <= data2); - static const bool less_than_equal23 = (data2 <= data3); - static const bool less_than_equal21 = (data2 <= data1); - static const bool less_than_equal32 = (data3 <= data2); - static const bool less_than_equal11 = (data1 <= data1); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(less_than_equal12); - CHECK_FALSE(less_than_equal23); - CHECK_TRUE(less_than_equal21); - CHECK_TRUE(less_than_equal32); - CHECK_TRUE(less_than_equal11); -#else - CHECK_TRUE(less_than_equal12); - CHECK_TRUE(less_than_equal23); - CHECK_FALSE(less_than_equal21); - CHECK_FALSE(less_than_equal32); - CHECK_TRUE(less_than_equal11); -#endif - } - - //************************************************************************* - TEST(test_less_than_equal_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool less_than_equal12 = (data1 <= data2); - static const bool less_than_equal23 = (data2 <= data3); - static const bool less_than_equal21 = (data2 <= data1); - static const bool less_than_equal32 = (data3 <= data2); - static const bool less_than_equal11 = (data1 <= data1); - -#ifdef TEST_GREATER_THAN - CHECK_FALSE(less_than_equal12); - CHECK_FALSE(less_than_equal23); - CHECK_TRUE(less_than_equal21); - CHECK_TRUE(less_than_equal32); - CHECK_TRUE(less_than_equal11); -#else - CHECK_TRUE(less_than_equal12); - CHECK_TRUE(less_than_equal23); - CHECK_FALSE(less_than_equal21); - CHECK_FALSE(less_than_equal32); - CHECK_TRUE(less_than_equal11); -#endif - } - - //************************************************************************* - TEST(test_greater_than) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool greater_than12 = (data1 > data2); - static const bool greater_than23 = (data2 > data3); - static const bool greater_than21 = (data2 > data1); - static const bool greater_than32 = (data3 > data2); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE(greater_than12); - CHECK_TRUE(greater_than23); - CHECK_FALSE(greater_than21); - CHECK_FALSE(greater_than32); -#else - CHECK_FALSE(greater_than12); - CHECK_FALSE(greater_than23); - CHECK_TRUE(greater_than21); - CHECK_TRUE(greater_than32); -#endif - } - - //************************************************************************* - TEST(test_greater_than_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool greater_than12 = (data1 > data2); - static const bool greater_than23 = (data2 > data3); - static const bool greater_than21 = (data2 > data1); - static const bool greater_than32 = (data3 > data2); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE(greater_than12); - CHECK_TRUE(greater_than23); - CHECK_FALSE(greater_than21); - CHECK_FALSE(greater_than32); -#else - CHECK_FALSE(greater_than12); - CHECK_FALSE(greater_than23); - CHECK_TRUE(greater_than21); - CHECK_TRUE(greater_than32); -#endif - } - - //************************************************************************* - TEST(test_greater_than_equal) - { - static const Data data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const Data data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool greater_than_equal12 = (data1 >= data2); - static const bool greater_than_equal23 = (data2 >= data3); - static const bool greater_than_equal21 = (data2 >= data1); - static const bool greater_than_equal32 = (data3 >= data2); - static const bool greater_than_equal11 = (data1 >= data1); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE(greater_than_equal12); - CHECK_TRUE(greater_than_equal23); - CHECK_FALSE(greater_than_equal21); - CHECK_FALSE(greater_than_equal32); - CHECK_TRUE(greater_than_equal11); -#else - CHECK_FALSE(greater_than_equal12); - CHECK_FALSE(greater_than_equal23); - CHECK_TRUE(greater_than_equal21); - CHECK_TRUE(greater_than_equal32); - CHECK_TRUE(greater_than_equal11); -#endif - } - - //************************************************************************* - TEST(test_greater_than_equal_with_transparent_comparator) - { - static const DataTransparentComparator data1{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('B'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data2{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('C'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const DataTransparentComparator data3{ value_type{Key('A'), 0 }, value_type{Key('B'), 1 }, value_type{Key('D'), 2 }, value_type{Key('D'), 3 }, value_type{Key('E'), 4 }, - value_type{Key('F'), 5 }, value_type{Key('G'), 6 }, value_type{Key('H'), 7 }, value_type{Key('I'), 8 }, value_type{Key('J'), 9 } }; - - static const bool greater_than_equal12 = (data1 >= data2); - static const bool greater_than_equal23 = (data2 >= data3); - static const bool greater_than_equal21 = (data2 >= data1); - static const bool greater_than_equal32 = (data3 >= data2); - static const bool greater_than_equal11 = (data1 >= data1); - -#ifdef TEST_GREATER_THAN - CHECK_TRUE(greater_than_equal12); - CHECK_TRUE(greater_than_equal23); - CHECK_FALSE(greater_than_equal21); - CHECK_FALSE(greater_than_equal32); - CHECK_TRUE(greater_than_equal11); -#else - CHECK_FALSE(greater_than_equal12); - CHECK_FALSE(greater_than_equal23); - CHECK_TRUE(greater_than_equal21); - CHECK_TRUE(greater_than_equal32); - CHECK_TRUE(greater_than_equal11); -#endif - } - }; -}