diff options
Diffstat (limited to 'test/source/TestSet.h')
| -rw-r--r-- | test/source/TestSet.h | 906 |
1 files changed, 0 insertions, 906 deletions
diff --git a/test/source/TestSet.h b/test/source/TestSet.h deleted file mode 100644 index 16f55c7..0000000 --- a/test/source/TestSet.h +++ /dev/null @@ -1,906 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// Copyright (c) Electronic Arts Inc. All rights reserved. -///////////////////////////////////////////////////////////////////////////// - - -#include "EASTLTest.h" -#include <EASTL/vector.h> -#include <EASTL/algorithm.h> -#include <EASTL/type_traits.h> -#include <EASTL/scoped_ptr.h> -#include <EASTL/random.h> - -EA_DISABLE_ALL_VC_WARNINGS() -#ifndef EA_COMPILER_NO_STANDARD_CPP_LIBRARY - #include <algorithm> -#endif -EA_RESTORE_ALL_VC_WARNINGS() - -#ifndef EA_COMPILER_NO_STANDARD_CPP_LIBRARY - - -/////////////////////////////////////////////////////////////////////////////// -// TestSetConstruction -// -// This test compares eastl::set/multiset to std::set/multiset. It could possibly -// work for comparing eastl::hash_set to C++11 std::unordered_set, but we would -// rather move towards making this test be independent of any std comparisons. -// -// Requires a container that can hold at least 1000 items. -// -template <typename T1, typename T2, bool bMultiset> -int TestSetConstruction() -{ - int nErrorCount = 0; - - TestObject::Reset(); - - { - eastl::scoped_ptr<T1> pt1A(new T1); // We use a pointers instead of concrete object because it's size may be huge. - eastl::scoped_ptr<T2> pt2A(new T2); - T1& t1A = *pt1A; - T2& t2A = *pt2A; - nErrorCount += CompareContainers(t1A, t2A, "Set ctor", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - VERIFY(t1A.validate()); - - - eastl::scoped_ptr<T1> pt1B(new T1); - eastl::scoped_ptr<T2> pt2B(new T2); - T1& t1B = *pt1B; - T2& t2B = *pt2B; - nErrorCount += CompareContainers(t1B, t2B, "Set ctor", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - eastl::scoped_ptr<T1> pt1C(new T1); - eastl::scoped_ptr<T2> pt2C(new T2); - T1& t1C = *pt1C; - T2& t2C = *pt2C; - for(int i = 0; i < 1000; i++) - { - t1C.insert(typename T1::value_type(typename T1::value_type(i))); - t2C.insert(typename T2::value_type(typename T2::value_type(i))); - VERIFY(t1C.validate()); - nErrorCount += CompareContainers(t1C, t2C, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - - eastl::scoped_ptr<T1> pt1D(new T1); - eastl::scoped_ptr<T2> pt2D(new T2); - T1& t1D = *pt1D; - T2& t2D = *pt2D; - nErrorCount += CompareContainers(t1D, t2D, "Set ctor", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - eastl::scoped_ptr<T1> pt1E(new T1(t1C)); - eastl::scoped_ptr<T2> pt2E(new T2(t2C)); - T1& t1E = *pt1E; - T2& t2E = *pt2E; - VERIFY(t1E.validate()); - nErrorCount += CompareContainers(t1E, t2E, "Set ctor", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - eastl::scoped_ptr<T1> pt1F(new T1(t1C.begin(), t1C.end())); - eastl::scoped_ptr<T2> pt2F(new T2(t2C.begin(), t2C.end())); - T1& t1F = *pt1F; - T2& t2F = *pt2F; - VERIFY(t1F.validate()); - nErrorCount += CompareContainers(t1F, t2F, "Set ctor", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // operator= - t1E = t1D; - t2E = t2D; - nErrorCount += CompareContainers(t1D, t2D, "Set operator=", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - nErrorCount += CompareContainers(t1E, t2E, "Set operator=", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // operator=(set&&) - // We test just the EASTL container here. - eastl::scoped_ptr<T1> pT1P(new T1); // We use a pointers instead of concrete object because it's size may be huge. - eastl::scoped_ptr<T1> pT1Q(new T1); - T1& t1P = *pT1P; - T1& t1Q = *pT1Q; - - typename T1::value_type v10(0); - typename T1::value_type v11(1); - typename T1::value_type v12(2); - typename T1::value_type v13(3); - typename T1::value_type v14(4); - typename T1::value_type v15(5); - - t1P.insert(v10); - t1P.insert(v11); - t1P.insert(v12); - - t1Q.insert(v13); - t1Q.insert(v14); - t1Q.insert(v15); - - t1Q = eastl::move(t1P); // We are effectively requesting to swap t1A with t1B. - //EATEST_VERIFY((t1P.size() == 3) && (t1P.find(v13) != t1P.end()) && (t1P.find(v14) != t1P.end()) && (t1P.find(v15) != t1P.end())); // Currently operator=(this_type&& x) clears x instead of swapping with it. - - - // swap - t1E.swap(t1D); - t2E.swap(t2D); - VERIFY(t1D.validate()); - VERIFY(t1E.validate()); - nErrorCount += CompareContainers(t1D, t2D, "Set swap", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - nErrorCount += CompareContainers(t1E, t2E, "Set swap", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // eastl::swap - eastl::swap(t1E, t1D); - std::swap(t2E, t2D); - VERIFY(t1D.validate()); - VERIFY(t1E.validate()); - nErrorCount += CompareContainers(t1D, t2D, "Global swap", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - nErrorCount += CompareContainers(t1E, t2E, "Global swap", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // clear - t1A.clear(); - t2A.clear(); - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set clear", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - t1B.clear(); - t2B.clear(); - VERIFY(t1B.validate()); - nErrorCount += CompareContainers(t1B, t2B, "Set clear", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // global operators (==, !=, <, etc.) - t1A.clear(); - t1B.clear(); - // Make t1A equal to t1B - t1A.insert(typename T1::value_type(0)); - t1A.insert(typename T1::value_type(1)); - t1A.insert(typename T1::value_type(2)); - - t1B.insert(typename T1::value_type(0)); - t1B.insert(typename T1::value_type(1)); - t1B.insert(typename T1::value_type(2)); - - VERIFY( (t1A == t1B)); - VERIFY(!(t1A != t1B)); - VERIFY( (t1A <= t1B)); - VERIFY( (t1A >= t1B)); - VERIFY(!(t1A < t1B)); - VERIFY(!(t1A > t1B)); - // Make t1A less than t1B - t1A.insert(typename T1::value_type(3)); - t1B.insert(typename T1::value_type(4)); - - VERIFY(!(t1A == t1B)); - VERIFY( (t1A != t1B)); - VERIFY( (t1A <= t1B)); - VERIFY(!(t1A >= t1B)); - VERIFY( (t1A < t1B)); - VERIFY(!(t1A > t1B)); - } - - VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - return nErrorCount; -} - - - - -/////////////////////////////////////////////////////////////////////////////// -// TestSetMutation -// -// Requires a container that can hold at least 1000 items. -// -EA_DISABLE_VC_WARNING(6262) -template <typename T1, typename T2, bool bMultiset> -int TestSetMutation() -{ - int nErrorCount = 0; - - TestObject::Reset(); - - { - eastl::scoped_ptr<T1> pt1A(new T1); // We use a pointers instead of concrete object because it's size may be huge. - eastl::scoped_ptr<T2> pt2A(new T2); - T1& t1A = *pt1A; - T2& t2A = *pt2A; - int i, iEnd, p; - - // Set up an array of values to randomize / permute. - eastl::vector<typename T1::value_type> valueArrayInsert; - - if(gEASTL_TestLevel >= kEASTL_TestLevelLow) - { - EASTLTest_Rand rng(EA::UnitTest::GetRandSeed()); - - valueArrayInsert.clear(); - - for(i = 0; i < 1000; i++) - { - valueArrayInsert.push_back(typename T1::value_type(i)); - - // Occasionally attempt to duplicate an element, both for set and multiset. - if(((i + 1) < 1000) && (rng.RandLimit(4) == 0)) - { - valueArrayInsert.push_back(typename T1::value_type(i)); - i++; - } - } - - for(p = 0; p < gEASTL_TestLevel * 100; p++) // For each permutation... - { - eastl::random_shuffle(valueArrayInsert.begin(), valueArrayInsert.end(), rng); - - // insert - for(i = 0, iEnd = (int)valueArrayInsert.size(); i < iEnd; i++) - { - typename T1::value_type& k = valueArrayInsert[i]; - - t1A.insert(typename T1::value_type(k)); // We expect that both arguments are the same. - t2A.insert(typename T2::value_type(k)); - - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - - // reverse iteration - typename T1::reverse_iterator r1 = t1A.rbegin(); - typename T2::reverse_iterator r2 = t2A.rbegin(); - - while(r1 != t1A.rend()) - { - typename T1::value_type k1 = *r1; - typename T2::value_type k2 = *r2; - VERIFY(k1 == k2); - } - - - // erase - for(i = 0, iEnd = (int)valueArrayInsert.size(); i < iEnd; i++) - { - typename T1::value_type& k = valueArrayInsert[i]; - - typename T1::size_type n1 = t1A.erase(k); - typename T2::size_type n2 = t2A.erase(k); - - VERIFY(n1 == n2); - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set erase", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - VERIFY((TestObject::sTOCount == 0) || (TestObject::sTOCount == (int64_t)valueArrayInsert.size())); // This test will only have meaning when T1 contains TestObject. - } - } - - - VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - - // Possibly do extended testing. - if(gEASTL_TestLevel > 6) - { - valueArrayInsert.clear(); - - for(i = 0; i < 9; i++) // Much more than this count would take too long to test all permutations. - valueArrayInsert.push_back(typename T1::value_type(i)); - - // Insert these values into the set in every existing permutation. - for(p = 0; std::next_permutation(valueArrayInsert.begin(), valueArrayInsert.end()); p++) // For each permutation... - { - for(i = 0, iEnd = (int)valueArrayInsert.size(); i < iEnd; i++) - { - typename T1::value_type& k = valueArrayInsert[i]; - - t1A.insert(typename T1::value_type(k)); // We expect that both arguments are the same. - t2A.insert(typename T2::value_type(k)); - - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - for(i = 0, iEnd = (int)valueArrayInsert.size(); i < iEnd; i++) - { - typename T1::value_type& k = valueArrayInsert[i]; - - t1A.erase(k); - t2A.erase(k); - - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set erase", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - VERIFY((TestObject::sTOCount == 0) || (TestObject::sTOCount == (int64_t)valueArrayInsert.size())); // This test will only have meaning when T1 contains TestObject. - } - } - } - - - VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - - { // Other insert and erase operations - - eastl::scoped_ptr<T1> pt1A(new T1); // We use a pointers instead of concrete object because it's size may be huge. - eastl::scoped_ptr<T2> pt2A(new T2); - T1& t1A = *pt1A; - T2& t2A = *pt2A; - int i; - - // Set up an array of values to randomize / permute. - eastl::vector<typename T1::value_type> valueArrayInsert1; - eastl::vector<typename T2::value_type> valueArrayInsert2; - - EASTLTest_Rand rng(EA::UnitTest::GetRandSeed()); - - for(i = 0; i < 100; i++) - { - valueArrayInsert1.push_back(typename T1::value_type(i)); - valueArrayInsert2.push_back(typename T2::value_type(i)); - - if(rng.RandLimit(3) == 0) - { - valueArrayInsert1.push_back(typename T1::value_type(i)); - valueArrayInsert2.push_back(typename T2::value_type(i)); - } - } - - - // insert(InputIterator first, InputIterator last) - t1A.insert(valueArrayInsert1.begin(), valueArrayInsert1.end()); - t2A.insert(valueArrayInsert2.begin(), valueArrayInsert2.end()); - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // iterator insert(iterator position, const value_type& value); - // - // If bMultiset == true, then the insertions below should fail due to the - // item being present. But they should return the correct iterator value. - typename T1::iterator it1 = t1A.insert(t1A.find(typename T1::value_type(2)), typename T1::value_type(1)); - typename T2::iterator it2 = t2A.insert(t2A.find(typename T2::value_type(2)), typename T2::value_type(1)); - VERIFY(t1A.validate()); - VERIFY(*it1 == typename T1::value_type(1)); - VERIFY(*it2 == typename T2::value_type(1)); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - it1 = t1A.insert(t1A.end(), typename T1::value_type(5)); - it2 = t2A.insert(t2A.end(), typename T2::value_type(5)); - VERIFY(t1A.validate()); - VERIFY(*it1 == typename T1::value_type(5)); - VERIFY(*it2 == typename T2::value_type(5)); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - // Now we remove these items so that the insertions above can succeed. - t1A.erase(t1A.find(typename T1::value_type(1))); - t2A.erase(t2A.find(typename T2::value_type(1))); - it1 = t1A.insert(t1A.find(typename T1::value_type(2)), typename T1::value_type(1)); - it2 = t2A.insert(t2A.find(typename T2::value_type(2)), typename T2::value_type(1)); - VERIFY(t1A.validate()); - VERIFY(*it1 == typename T1::value_type(1)); - VERIFY(*it2 == typename T2::value_type(1)); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - t1A.erase(t1A.find(typename T1::value_type(5))); - t2A.erase(t2A.find(typename T2::value_type(5))); - it1 = t1A.insert(t1A.end(), typename T1::value_type(5)); - it2 = t2A.insert(t2A.end(), typename T2::value_type(5)); - VERIFY(t1A.validate()); - VERIFY(*it1 == typename T1::value_type(5)); - VERIFY(*it2 == typename T2::value_type(5)); - nErrorCount += CompareContainers(t1A, t2A, "Set insert", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - // iterator erase(iterator first, iterator last); - typename T1::iterator it11 = t1A.find(typename T1::value_type(17)); - typename T1::iterator it12 = t1A.find(typename T2::value_type(37)); - t1A.erase(it11, it12); - - typename T2::iterator it21 = t2A.find(typename T1::value_type(17)); - typename T2::iterator it22 = t2A.find(typename T2::value_type(37)); - t2A.erase(it21, it22); - - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set erase(first, last)", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // iterator erase(iterator position); - t1A.erase(t1A.find(typename T1::value_type(60))); - t2A.erase(t2A.find(typename T1::value_type(60))); - VERIFY(t1A.validate()); - nErrorCount += CompareContainers(t1A, t2A, "Set erase(first, last)", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - - - // Disabled because this function isn't exposed outside the rbtree yet. - // void erase(const value_type* first, const value_type* last); - //typename T1::value_type keyArray1[3] = { typename T1::value_type(70), typename T1::value_type(71), typename T1::value_type(72) }; - //typename T2::value_type keyArray2[3] = { typename T2::value_type(70), typename T2::value_type(71), typename T2::value_type(72) }; - //t1A.erase(keyArray1 + 0, keyArray1 + 3); - //t2A.erase(keyArray2 + 0, keyArray2 + 3); - //VERIFY(t1A.validate()); - //nErrorCount += CompareContainers(t1A, t2A, "Set erase(first, last)", eastl::use_self<typename T1::value_type>(), eastl::use_self<typename T2::value_type>()); - } - - { - // set(std::initializer_list<value_type> ilist, const Compare& compare = Compare(), const allocator_type& allocator = EASTL_MAP_DEFAULT_ALLOCATOR); - // this_type& operator=(std::initializer_list<T> ilist); - // void insert(std::initializer_list<value_type> ilist); - #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS) - T1 mySet = { typename T1::value_type(10), typename T1::value_type(11) }; - EATEST_VERIFY(mySet.size() == 2); - typename T1::iterator it = mySet.begin(); - EATEST_VERIFY(*it == typename T1::value_type(10)); - it = mySet.rbegin().base(); - EATEST_VERIFY(*--it == typename T1::value_type(11)); - - mySet = {typename T1::value_type(20), typename T1::value_type(21) }; - EATEST_VERIFY(mySet.size() == 2); - EATEST_VERIFY(*mySet.begin() == typename T1::value_type(20)); - it = mySet.rbegin().base(); - EATEST_VERIFY(*--it == typename T1::value_type(21)); - - mySet.insert({ typename T1::value_type(40), typename T1::value_type(41) }); - EATEST_VERIFY(mySet.size() == 4); - it = mySet.rbegin().base(); - EATEST_VERIFY(*--it == typename T1::value_type(41)); - #endif - } - - VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - return nErrorCount; -} -EA_RESTORE_VC_WARNING() - - -#endif // EA_COMPILER_NO_STANDARD_CPP_LIBRARY - - - - -template <typename T1> -int TestSetSpecific(T1& /*t1A*/, eastl::false_type) // false_type means this is a map and not a multimap. -{ - return 0; -} - - -template <typename T1> -int TestSetSpecific(T1& t1A, eastl::true_type) // true_type means this is a multimap and not a map. -{ - int nErrorCount = 0; - - // equal_range_small (multiset only) - eastl::pair<typename T1::iterator, typename T1::iterator> er = t1A.equal_range_small(typename T1::value_type(499)); - VERIFY(*er.first == typename T1::value_type(499)); - VERIFY(*er.second == typename T1::value_type(501)); - - er = t1A.equal_range_small(typename T1::value_type(-1)); - VERIFY(er.first == er.second); - VERIFY(er.first == t1A.begin()); - - return nErrorCount; -} - - -// Just for the purposes of the map::find_as test below, we declare the following. -// The map::find_as function searches a container of X for a type Y, where the user -// defines the equality of X to Y. The purpose of TSetComparable is to be a generic type Y -// that can be used for any X. We need to make this generic because the whole TestMapSearch -// function below is templated on type T1 and so we don't know what T1 is ahead of time. - -template <typename T> -struct TSetComparable -{ - T b; - - TSetComparable() : b() { } - TSetComparable(const T& a) : b(a){ } - const TSetComparable& operator=(const T& a) { b = a; return *this; } - const TSetComparable& operator=(const TSetComparable& x) { b = x.b; return *this; } - operator const T&() const { return b; } -}; - - -/////////////////////////////////////////////////////////////////////////////// -// TestSetSearch -// -// This function is designed to work with set, fixed_set (and not hash containers). -// Requires a container that can hold at least 1000 items. -// -template <typename T1, bool bMultimap> -int TestSetSearch() -{ - int nErrorCount = 0; - - TestObject::Reset(); - - { // Test find, lower_bound, upper_bound, etc.. - eastl::scoped_ptr<T1> pt1A(new T1); // We use a pointers instead of concrete object because it's size may be huge. - T1& t1A = *pt1A; - int i, iEnd; - typename T1::iterator it; - - // Set up an array of values to randomize / permute. - eastl::vector<typename T1::value_type> valueArrayInsert; - - for(i = 0; i < 1000; i++) - valueArrayInsert.push_back(typename T1::value_type(i)); - - EASTLTest_Rand rng(EA::UnitTest::GetRandSeed()); - eastl::random_shuffle(valueArrayInsert.begin(), valueArrayInsert.end(), rng); - - - // insert - for(i = 0, iEnd = (int)valueArrayInsert.size(); i < iEnd; i++) - { - typename T1::value_type k(i); - t1A.insert(typename T1::value_type(k)); - - it = t1A.find(k); - VERIFY(it != t1A.end()); - } - - - // find - for(i = 0; i < 1000; i++) - { - typename T1::value_type k(i); - it = t1A.find(k); - - VERIFY(it != t1A.end()); - VERIFY(*it == k); - } - - it = t1A.find(typename T1::value_type(-1)); - VERIFY(it == t1A.end()); - - it = t1A.find(typename T1::value_type(1001)); - VERIFY(it == t1A.end()); - - - // find_as - typedef TSetComparable<typename T1::key_type> TC; - - // Normally we use find_as to find via a different type, but we can test it here like this. - for(i = 0; i < 1000; i++) - { - TC k = typename T1::key_type(i); - it = t1A.find_as(k, eastl::less_2<typename T1::key_type, TC>()); - - VERIFY(it != t1A.end()); - VERIFY(*it == k); - } - - it = t1A.find_as(TC(typename T1::key_type(-1)), eastl::less_2<typename T1::key_type, TC>()); - VERIFY(it == t1A.end()); - - it = t1A.find_as(TC(typename T1::key_type(1001)), eastl::less_2<typename T1::key_type, TC>()); - VERIFY(it == t1A.end()); - - - // lower_bound - it = t1A.lower_bound(typename T1::value_type(0)); - VERIFY(it == t1A.begin()); - - it = t1A.lower_bound(typename T1::value_type(-1)); - VERIFY(it == t1A.begin()); - - it = t1A.lower_bound(typename T1::value_type(1001)); - VERIFY(it == t1A.end()); - - t1A.erase(typename T1::value_type(500)); - it = t1A.lower_bound(typename T1::value_type(500)); - VERIFY(*it == typename T1::value_type(501)); - - - // upper_bound - it = t1A.upper_bound(typename T1::value_type(-1)); - VERIFY(it == t1A.begin()); - - it = t1A.upper_bound(typename T1::value_type(499)); - VERIFY(*it == typename T1::value_type(501)); - - it = t1A.upper_bound(typename T1::value_type(-1)); - VERIFY(*it == typename T1::value_type(0)); - - it = t1A.upper_bound(typename T1::value_type(1000)); - VERIFY(it == t1A.end()); - - - // count - typename T1::size_type n = t1A.count(typename T1::value_type(-1)); - VERIFY(n == 0); - - n = t1A.count(typename T1::value_type(0)); - VERIFY(n == 1); - - n = t1A.count(typename T1::value_type(500)); // We removed 500 above. - VERIFY(n == 0); - - n = t1A.count(typename T1::value_type(1001)); - VERIFY(n == 0); - - - // equal_range - eastl::pair<typename T1::iterator, typename T1::iterator> er = t1A.equal_range(typename T1::value_type(200)); - VERIFY(*er.first == typename T1::value_type(200)); - - er = t1A.equal_range(typename T1::value_type(499)); - VERIFY(*er.first == typename T1::value_type(499)); - VERIFY(*er.second == typename T1::value_type(501)); - - er = t1A.equal_range(typename T1::value_type(-1)); - VERIFY(er.first == er.second); - VERIFY(er.first == t1A.begin()); - - - // Some tests need to be differently between map and multimap. - nErrorCount += TestSetSpecific(t1A, eastl::integral_constant<bool, bMultimap>()); - } - - VERIFY(TestObject::IsClear()); - TestObject::Reset(); - - return nErrorCount; -} - - - -/////////////////////////////////////////////////////////////////////////////// -// TestSetCpp11 -// -// This function is designed to work with set, fixed_set, hash_set, fixed_hash_set -// -template <typename T1> -int TestSetCpp11() -{ - int nErrorCount = 0; - - // template <class... Args> - // insert_return_type emplace(Args&&... args); - // - // template <class... Args> - // iterator emplace_hint(const_iterator position, Args&&... args); - // - // insert_return_type insert(value_type&& value); - // iterator insert(const_iterator position, value_type&& value); - TestObject::Reset(); - - typedef T1 TOSet; - typename TOSet::insert_return_type toSetInsertResult; - typename TOSet::iterator toSetIterator; - - TOSet toSet; - TestObject to0(0); - TestObject to1(1); - - toSetInsertResult = toSet.emplace(to0); - EATEST_VERIFY(toSetInsertResult.second == true); - //EATEST_VERIFY((TestObject::sTOCopyCtorCount == 2) && (TestObject::sTOMoveCtorCount == 1)); // Disabled until we can guarantee its behavior and deal with how it's different between compilers of differing C++11 support. - - toSetInsertResult = toSet.emplace(eastl::move(to1)); - EATEST_VERIFY(toSetInsertResult.second == true); - - // insert_return_type t1A.emplace(value_type&& value); - TestObject to40(4); - EATEST_VERIFY(toSet.find(to40) == toSet.end()); - EATEST_VERIFY(to40.mX == 4); // It should change to 0 below during the move swap. - toSetInsertResult = toSet.emplace(eastl::move(to40)); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to40) != toSet.end()); - EATEST_VERIFY(to40.mX == 0); - - TestObject to41(4); - toSetInsertResult = toSet.emplace(eastl::move(to41)); - EATEST_VERIFY(toSetInsertResult.second == false); - EATEST_VERIFY(toSet.find(to41) != toSet.end()); - - // iterator t1A.emplace_hint(const_iterator position, value_type&& value); - TestObject to50(5); - toSetInsertResult = toSet.emplace(eastl::move(to50)); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to50) != toSet.end()); - - TestObject to51(5); - toSetIterator = toSet.emplace_hint(toSetInsertResult.first, eastl::move(to51)); - EATEST_VERIFY(*toSetIterator == TestObject(5)); - EATEST_VERIFY(toSet.find(to51) != toSet.end()); - - TestObject to6(6); - toSetIterator = toSet.emplace_hint(toSet.begin(), eastl::move(to6)); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == TestObject(6)); - EATEST_VERIFY(toSet.find(to6) != toSet.end()); - - TestObject to2(2); - EATEST_VERIFY(toSet.find(to2) == toSet.end()); - toSetInsertResult = toSet.emplace(to2); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to2) != toSet.end()); - toSetInsertResult = toSet.emplace(to2); - EATEST_VERIFY(toSetInsertResult.second == false); - EATEST_VERIFY(toSet.find(to2) != toSet.end()); - - // iterator t1A.emplace_hint(const_iterator position, const value_type& value); - TestObject to70(7); - toSetInsertResult = toSet.emplace(to70); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to70) != toSet.end()); - - TestObject to71(7); - toSetIterator = toSet.emplace_hint(toSetInsertResult.first, to71); - EATEST_VERIFY(*toSetIterator == to71); - EATEST_VERIFY(toSet.find(to71) != toSet.end()); - - TestObject to8(8); - toSetIterator = toSet.emplace_hint(toSet.begin(), to8); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == to8); - EATEST_VERIFY(toSet.find(to8) != toSet.end()); - - //pair<iterator,bool> t1A.insert(value_type&& value); - TestObject to3(3); - EATEST_VERIFY(toSet.find(to3) == toSet.end()); - toSetInsertResult = toSet.insert(TestObject(to3)); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to3) != toSet.end()); - toSetInsertResult = toSet.insert(TestObject(to3)); - EATEST_VERIFY(toSetInsertResult.second == false); - EATEST_VERIFY(toSet.find(to3) != toSet.end()); - - - // iterator t1A.insert(const_iterator position, value_type&& value); - TestObject to90(9); - toSetInsertResult = toSet.emplace(eastl::move(to90)); - EATEST_VERIFY(toSetInsertResult.second == true); - EATEST_VERIFY(toSet.find(to90) != toSet.end()); - - TestObject to91(9); - toSetIterator = toSet.emplace_hint(toSetInsertResult.first, eastl::move(to91)); - EATEST_VERIFY(*toSetIterator == TestObject(9)); - EATEST_VERIFY(toSet.find(to91) != toSet.end()); - - TestObject to10(10); - toSetIterator = toSet.emplace_hint(toSet.begin(), eastl::move(to10)); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == TestObject(10)); - EATEST_VERIFY(toSet.find(to10) != toSet.end()); - - return nErrorCount; -} - - - - - - -/////////////////////////////////////////////////////////////////////////////// -// TestMultisetCpp11 -// -// This function is designed to work with multiset, fixed_multiset, hash_multiset, fixed_hash_multiset -// -// This is similar to the TestSetCpp11 function, with some differences related -// to handling of duplicate entries. -// -template <typename T1> -int TestMultisetCpp11() -{ - int nErrorCount = 0; - - // template <class... Args> - // insert_return_type emplace(Args&&... args); - // - // template <class... Args> - // iterator emplace_hint(const_iterator position, Args&&... args); - // - // insert_return_type insert(value_type&& value); - // iterator insert(const_iterator position, value_type&& value); - TestObject::Reset(); - - typedef T1 TOSet; - typename TOSet::iterator toSetIterator; - - TOSet toSet; - TestObject to0(0); - TestObject to1(1); - - toSetIterator = toSet.emplace(to0); - EATEST_VERIFY(*toSetIterator == TestObject(0)); - //EATEST_VERIFY((TestObject::sTOCopyCtorCount == 2) && (TestObject::sTOMoveCtorCount == 1)); // Disabled until we can guarantee its behavior and deal with how it's different between compilers of differing C++11 support. - - toSetIterator = toSet.emplace(eastl::move(to1)); - EATEST_VERIFY(*toSetIterator == TestObject(1)); - - // insert_return_type t1A.emplace(value_type&& value); - TestObject to40(4); - EATEST_VERIFY(toSet.find(to40) == toSet.end()); - EATEST_VERIFY(to40.mX == 4); // It should change to 0 below during the move swap. - toSetIterator = toSet.emplace(eastl::move(to40)); - EATEST_VERIFY(*toSetIterator == TestObject(4)); - EATEST_VERIFY(toSet.find(to40) != toSet.end()); - EATEST_VERIFY(to40.mX == 0); - - TestObject to41(4); - toSetIterator = toSet.emplace(eastl::move(to41)); // multiset can insert another of these. - EATEST_VERIFY(*toSetIterator == TestObject(4)); - EATEST_VERIFY(toSet.find(to41) != toSet.end()); - - // iterator t1A.emplace_hint(const_iterator position, value_type&& value); - TestObject to50(5); - toSetIterator = toSet.emplace(eastl::move(to50)); - EATEST_VERIFY(*toSetIterator == TestObject(5)); - EATEST_VERIFY(toSet.find(to50) != toSet.end()); - - TestObject to51(5); - toSetIterator = toSet.emplace_hint(toSetIterator, eastl::move(to51)); - EATEST_VERIFY(*toSetIterator == TestObject(5)); - EATEST_VERIFY(toSet.find(to51) != toSet.end()); - - TestObject to6(6); - toSetIterator = toSet.emplace_hint(toSet.begin(), eastl::move(to6)); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == TestObject(6)); - EATEST_VERIFY(toSet.find(to6) != toSet.end()); - - TestObject to2(2); - EATEST_VERIFY(toSet.find(to2) == toSet.end()); - toSetIterator = toSet.emplace(to2); - EATEST_VERIFY(*toSetIterator == TestObject(2)); - EATEST_VERIFY(toSet.find(to2) != toSet.end()); - toSetIterator = toSet.emplace(to2); - EATEST_VERIFY(*toSetIterator == TestObject(2)); - EATEST_VERIFY(toSet.find(to2) != toSet.end()); - - // iterator t1A.emplace_hint(const_iterator position, const value_type& value); - TestObject to70(7); - toSetIterator = toSet.emplace(to70); - EATEST_VERIFY(*toSetIterator == TestObject(7)); - EATEST_VERIFY(toSet.find(to70) != toSet.end()); - - TestObject to71(7); - toSetIterator = toSet.emplace_hint(toSetIterator, to71); - EATEST_VERIFY(*toSetIterator == to71); - EATEST_VERIFY(toSet.find(to71) != toSet.end()); - - TestObject to8(8); - toSetIterator = toSet.emplace_hint(toSet.begin(), to8); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == to8); - EATEST_VERIFY(toSet.find(to8) != toSet.end()); - - // insert_return_type t1A.insert(value_type&& value); - TestObject to3(3); - EATEST_VERIFY(toSet.find(to3) == toSet.end()); - toSetIterator = toSet.insert(TestObject(to3)); - EATEST_VERIFY(*toSetIterator == TestObject(3)); - EATEST_VERIFY(toSet.find(to3) != toSet.end()); - toSetIterator = toSet.insert(TestObject(to3)); - EATEST_VERIFY(*toSetIterator == TestObject(3)); - EATEST_VERIFY(toSet.find(to3) != toSet.end()); - - // iterator t1A.insert(const_iterator position, value_type&& value); - TestObject to90(9); - toSetIterator = toSet.emplace(eastl::move(to90)); - EATEST_VERIFY(*toSetIterator == TestObject(9)); - EATEST_VERIFY(toSet.find(to90) != toSet.end()); - - TestObject to91(9); - toSetIterator = toSet.emplace_hint(toSetIterator, eastl::move(to91)); - EATEST_VERIFY(*toSetIterator == TestObject(9)); - EATEST_VERIFY(toSet.find(to91) != toSet.end()); - - TestObject to10(10); - toSetIterator = toSet.emplace_hint(toSet.begin(), eastl::move(to10)); // specify a bad hint. Insertion should still work. - EATEST_VERIFY(*toSetIterator == TestObject(10)); - EATEST_VERIFY(toSet.find(to10) != toSet.end()); - - return nErrorCount; -} - - - - - - - |