/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////


#include "EASTLTest.h"
#include "TestMap.h"
#include "TestSet.h"
#include <EASTL/hash_set.h>
#include <EASTL/hash_map.h>
#include <EASTL/unordered_set.h>
#include <EASTL/unordered_map.h>
#include <EASTL/map.h>
#include <EASTL/string.h>
#include <EASTL/algorithm.h>
#include <EASTL/vector.h>
#include <EASTL/unique_ptr.h>

EA_DISABLE_ALL_VC_WARNINGS()
#include <string.h>
EA_RESTORE_ALL_VC_WARNINGS()


using namespace eastl;

namespace eastl
{
	template <> 
	struct hash<Align32>
	{
		size_t operator()(const Align32& a32) const 
			{ return static_cast<size_t>(a32.mX); }
	};

	// extension to hash an eastl::pair
	template <typename T1, typename T2>
	struct hash<pair<T1, T2>>
	{
		size_t operator()(const pair<T1, T2>& c) const
		{
			return static_cast<size_t>(hash<T1>()(c.first) ^ hash<T2>()(c.second));
		}
	};
}

// For regression code below.
class HashRegressionA { public: int x; };
class HashRegressionB { public: int y; };


// For regression code below.
struct Struct {
	char8_t name[128];
};


// For regression code below.
template<class HashType>
struct HashTest
{
	template<typename... Args>
	auto operator()(Args&&... args)
	{
		return eastl::hash<HashType>{}(eastl::forward<Args>(args)...);
	}
};



// What we are doing here is creating a special case of a hashtable where the key compare
// function is not the same as the value operator==. 99% of the time when you create a 
// hashtable the key compare (predicate) is simply key_equal or something else that's
// identical to operator== for the hashtable value type. But for some tests we want
// to exercise the case that these aren't different. A result of this difference is that
// you can lookup an element in a hash table and the returned value is not == to the 
// value you looked up, because it succeeds the key compare but not operator==.
struct HashtableValue
{
	HashtableValue(eastl_size_t d = 0, eastl_size_t e = 0) : mData(d), mExtra(e){}
	void Set(eastl_size_t d, eastl_size_t e = 0) { mData = d; mExtra = e; }

	eastl_size_t mData;
	eastl_size_t mExtra;
};

bool operator==(const HashtableValue& htv1, const HashtableValue& htv2)
{
	return (htv1.mData == htv2.mData) && (htv1.mExtra == htv2.mExtra); // Fully compare the HashTableValue.
}

struct HashtableValuePredicate
{
	bool operator()(const HashtableValue& htv1, const HashtableValue& htv2) const
		{ return (htv1.mData == htv2.mData); } // Compare just the mData portion of HashTableValue.
};

struct HashtableValueHash
{
	size_t operator()(const HashtableValue& htv) const 
		{ return static_cast<size_t>(htv.mData); }
};




// Explicit Template instantiations.
// These tell the compiler to compile all the functions for the given class.
template class eastl::hashtable<int,
                                eastl::pair<const int, int>,
                                eastl::allocator,
                                eastl::use_first<eastl::pair<const int, int>>,
                                eastl::equal_to<int>,
                                eastl::hash<int>,
                                mod_range_hashing,
                                default_ranged_hash,
                                prime_rehash_policy,
                                true, // bCacheHashCode
                                true, // bMutableIterators
                                true  // bUniqueKeys
                                >;
template class eastl::hashtable<int,
								eastl::pair<const int, int>,
								eastl::allocator,
								eastl::use_first<eastl::pair<const int, int>>,
								eastl::equal_to<int>,
								eastl::hash<int>,
								mod_range_hashing,
								default_ranged_hash,
								prime_rehash_policy,
								false, // bCacheHashCode
								true,  // bMutableIterators
								true   // bUniqueKeys
								>;
// TODO(rparolin): known compiler error, we should fix this.
// template class eastl::hashtable<int,
//                                 eastl::pair<const int, int>,
//                                 eastl::allocator,
//                                 eastl::use_first<eastl::pair<const int, int>>,
//                                 eastl::equal_to<int>,
//                                 eastl::hash<int>,
//                                 mod_range_hashing,
//                                 default_ranged_hash,
//                                 prime_rehash_policy,
//                                 false, // bCacheHashCode
//                                 true,  // bMutableIterators
//                                 false  // bUniqueKeys
//                                 >;

// Note these will only compile non-inherited functions.  We provide explicit
// template instantiations for the hashtable base class above to get compiler
// coverage of those inherited hashtable functions.
template class eastl::hash_set<int>;
template class eastl::hash_multiset<int>;
template class eastl::hash_map<int, int>;
template class eastl::hash_multimap<int, int>;
template class eastl::hash_set<Align32>;
template class eastl::hash_multiset<Align32>;
template class eastl::hash_map<Align32, Align32>;
template class eastl::hash_multimap<Align32, Align32>;

// validate static assumptions about hashtable core types
typedef eastl::hash_node<int, false> HashNode1;
typedef eastl::hash_node<int, true> HashNode2;
static_assert(eastl::is_default_constructible<HashNode1>::value, "hash_node static error");
static_assert(eastl::is_default_constructible<HashNode2>::value, "hash_node static error");
static_assert(eastl::is_copy_constructible<HashNode1>::value, "hash_node static error");
static_assert(eastl::is_copy_constructible<HashNode2>::value, "hash_node static error");
static_assert(eastl::is_move_constructible<HashNode1>::value, "hash_node static error");
static_assert(eastl::is_move_constructible<HashNode2>::value, "hash_node static error");

// A custom hash function that has a high number of collisions is used to ensure many keys share the same hash value.
struct colliding_hash
{
	size_t operator()(const int& val) const 
		{ return static_cast<size_t>(val % 3); }
};



int TestHash()
{   
	int nErrorCount = 0;

	{  // Test declarations
		hash_set<int>           hashSet;
		hash_multiset<int>      hashMultiSet;
		hash_map<int, int>      hashMap;
		hash_multimap<int, int> hashMultiMap;

		hash_set<int> hashSet2(hashSet);
		EATEST_VERIFY(hashSet2.size() == hashSet.size());
		EATEST_VERIFY(hashSet2 == hashSet);

		hash_multiset<int> hashMultiSet2(hashMultiSet);
		EATEST_VERIFY(hashMultiSet2.size() == hashMultiSet.size());
		EATEST_VERIFY(hashMultiSet2 == hashMultiSet);

		hash_map<int, int> hashMap2(hashMap);
		EATEST_VERIFY(hashMap2.size() == hashMap.size());
		EATEST_VERIFY(hashMap2 == hashMap);

		hash_multimap<int, int> hashMultiMap2(hashMultiMap);
		EATEST_VERIFY(hashMultiMap2.size() == hashMultiMap.size());
		EATEST_VERIFY(hashMultiMap2 == hashMultiMap);


		// allocator_type& get_allocator();
		// void            set_allocator(const allocator_type& allocator);
		hash_set<int>::allocator_type& allocator = hashSet.get_allocator();
		hashSet.set_allocator(EASTLAllocatorType());
		hashSet.set_allocator(allocator);
		// To do: Try to find something better to test here.


		// const key_equal& key_eq() const;
		// key_equal&       key_eq();
		hash_set<int>       hs;
		const hash_set<int> hsc;

		const hash_set<int>::key_equal& ke = hsc.key_eq();
		hs.key_eq() = ke;


		// const char*     get_name() const;
		// void            set_name(const char* pName);
		#if EASTL_NAME_ENABLED
			hashMap.get_allocator().set_name("test");
			const char* pName = hashMap.get_allocator().get_name();
			EATEST_VERIFY(equal(pName, pName + 5, "test"));
		#endif
	}


	{
		hash_set<int> hashSet;

		// Clear a newly constructed, already empty container.
		hashSet.clear(true);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.size() == 0);
		EATEST_VERIFY(hashSet.bucket_count() == 1);

		for(int i = 0; i < 100; ++i)
			hashSet.insert(i);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.size() == 100);

		hashSet.clear(true);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.size() == 0);
		EATEST_VERIFY(hashSet.bucket_count() == 1);

		for(int i = 0; i < 100; ++i)
			hashSet.insert(i);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.size() == 100);

		hashSet.clear(true);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.size() == 0);
		EATEST_VERIFY(hashSet.bucket_count() == 1);
	}


	{   // Test hash_set

		// size_type          size() const
		// bool               empty() const
		// insert_return_type insert(const value_type& value);
		// insert_return_type insert(const value_type& value, hash_code_t c, node_type* pNodeNew = NULL);
		// iterator           insert(const_iterator, const value_type& value);
		// iterator           find(const key_type& k);
		// const_iterator     find(const key_type& k) const;
		// size_type          count(const key_type& k) const;

		typedef hash_set<int> HashSetInt;

		HashSetInt hashSet;
		const HashSetInt::size_type kCount = 10000;

		EATEST_VERIFY(hashSet.empty());
		EATEST_VERIFY(hashSet.size() == 0);
		EATEST_VERIFY(hashSet.count(0) == 0);

		for(int i = 0; i < (int)kCount; i++)
			hashSet.insert(i);

		EATEST_VERIFY(!hashSet.empty());
		EATEST_VERIFY(hashSet.size() == kCount);
		EATEST_VERIFY(hashSet.count(0) == 1);

		for(HashSetInt::iterator it = hashSet.begin(); it != hashSet.end(); ++it)
		{
			int value = *it;
			EATEST_VERIFY(value < (int)kCount);
		}

		for(int i = 0; i < (int)kCount * 2; i++)
		{
			HashSetInt::iterator it = hashSet.find(i);

			if(i < (int)kCount)
				EATEST_VERIFY(it != hashSet.end());
			else
				EATEST_VERIFY(it == hashSet.end());
		}

		// insert_return_type insert(const value_type& value, hash_code_t c, node_type* pNodeNew = NULL);
		HashSetInt::node_type* pNode = hashSet.allocate_uninitialized_node();
		HashSetInt::insert_return_type r = hashSet.insert(eastl::hash<int>()(999999), pNode, 999999);
		EATEST_VERIFY(r.second == true);
		pNode = hashSet.allocate_uninitialized_node();
		r = hashSet.insert(eastl::hash<int>()(999999), pNode, 999999);
		EATEST_VERIFY(r.second == false);
		hashSet.free_uninitialized_node(pNode);
		hashSet.erase(999999);


		// iterator       begin();
		// const_iterator begin() const;
		// iterator       end();
		// const_iterator end() const;

		int* const pIntArray = new int[kCount];
		memset(pIntArray, 0, kCount * sizeof(int)); // We want to make sure each element is present only once.
		int nCount = 0;

		for(HashSetInt::iterator it = hashSet.begin(); it != hashSet.end(); ++it, ++nCount)
		{
			int i = *it;

			EATEST_VERIFY((i >= 0) && (i < (int)kCount) && (pIntArray[i] == 0));
			pIntArray[i] = 1;
		}

		EATEST_VERIFY(nCount == (int)kCount);
		delete[] pIntArray;
	}


	{
		// size_type bucket_count() const
		// size_type bucket_size(size_type n) const
		// float load_factor() const
		// float get_max_load_factor() const;
		// void  set_max_load_factor(float fMaxLoadFactor);
		// void rehash(size_type n);
		// const RehashPolicy& rehash_policy() const
		// void  rehash_policy(const RehashPolicy& rehashPolicy);

		typedef hash_set<int> HashSetInt;

		HashSetInt hashSet;

		float fLoadFactor = hashSet.load_factor();
		EATEST_VERIFY(fLoadFactor == 0.f);

		hashSet.set_max_load_factor(65536.f * 512.f);
		float fMaxLoadFactor = hashSet.get_max_load_factor();
		EATEST_VERIFY(fMaxLoadFactor == (65536.f * 512.f));

		hashSet.rehash(20);
		HashSetInt::size_type n = hashSet.bucket_count();
		EATEST_VERIFY((n >= 20) && (n < 25));
		
		for(int i = 0; i < 100000; i++)
			hashSet.insert(i); // This also tests for high loading.

		HashSetInt::size_type n2 = hashSet.bucket_count();
		EATEST_VERIFY(n2 == n); // Verify no rehashing has occured, due to our high load factor.

		n = hashSet.bucket_size(0);
		EATEST_VERIFY(n >= ((hashSet.size() / hashSet.bucket_count()) / 2)); // It will be some high value. We divide by 2 to give it some slop.
		EATEST_VERIFY(hashSet.validate());

		hash_set<int>::rehash_policy_type rp = hashSet.rehash_policy();
		rp.mfGrowthFactor = 1.5f;
		hashSet.rehash_policy(rp);
		EATEST_VERIFY(hashSet.validate());


		// local_iterator       begin(size_type n);
		// local_iterator       end(size_type n);
		// const_local_iterator begin(size_type n) const;
		// const_local_iterator end(size_type n) const;

		HashSetInt::size_type b = hashSet.bucket_count() - 1;
		hash<int> IntHash;
		for(HashSetInt::const_local_iterator cli = hashSet.begin(b); cli != hashSet.end(b); ++cli)
		{
			int v = *cli;
			EATEST_VERIFY((IntHash(v) % hashSet.bucket_count()) == b);
		}


		// clear();

		hashSet.clear();
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.empty());
		EATEST_VERIFY(hashSet.size() == 0);
		EATEST_VERIFY(hashSet.count(0) == 0);

		hashSet.clear(true);
		EATEST_VERIFY(hashSet.validate());
		EATEST_VERIFY(hashSet.bucket_count() == 1);
	}


	{
		// void reserve(size_type nElementCount);
		nErrorCount += HashContainerReserveTest<hash_set<int>>()();
		nErrorCount += HashContainerReserveTest<hash_multiset<int>>()();
		nErrorCount += HashContainerReserveTest<hash_map<int, int>>()();
		nErrorCount += HashContainerReserveTest<hash_multimap<int, int>>()();
	}


	{   // Test hash_set with cached hash code.

		// insert_return_type insert(const value_type& value) ;
		// iterator       find(const key_type& k);
		// const_iterator find(const key_type& k) const;

		typedef hash_set<int, hash<int>, equal_to<int>, EASTLAllocatorType, true> HashSetIntC;

		HashSetIntC hashSet;
		const int kCount = 10000;

		for(int i = 0; i < kCount; i++)
			hashSet.insert(i);

		for(HashSetIntC::iterator it = hashSet.begin(); it != hashSet.end(); ++it)
		{
			int value = *it;
			EATEST_VERIFY(value < kCount);
		}

		for(int i = 0; i < kCount * 2; i++)
		{
			HashSetIntC::iterator it = hashSet.find(i);
			if(i < kCount)
				EATEST_VERIFY(it != hashSet.end());
			else
				EATEST_VERIFY(it == hashSet.end());
		}
	}

	{
		// ENABLE_IF_HASHCODE_U32(HashCodeT, iterator)       find_by_hash(HashCodeT c)
		// ENABLE_IF_HASHCODE_U32(HashCodeT, const_iterator) find_by_hash(HashCodeT c) const
		{
			// NOTE(rparolin):
			// these overloads of find_by_hash contains a static assert that forces a compiler error in the event it is
			// used with a hashtable configured to not cache the hash value in the node.
		}

		// iterator                                          find_by_hash(const key_type& k, hash_code_t c)
		// const_iterator                                    find_by_hash(const key_type& k, hash_code_t c) const
		#ifdef EA_COMPILER_CPP14_ENABLED 
		{
			auto FindByHashTest = [&nErrorCount](auto& hashSet)
			{
				const int kCount = 10000;
				for(int i = 0; i < kCount; i++)
					hashSet.insert(i);

				for(int i = 0; i < kCount * 2; i++)
				{
					auto it = hashSet.find_by_hash(i, i);

					if(i < kCount)
						EATEST_VERIFY(it != hashSet.end());
					else
						EATEST_VERIFY(it == hashSet.end());
				}
			};

			{
				typedef hash_set<int, hash<int>, equal_to<int>, EASTLAllocatorType, true> HashSetIntC;
				HashSetIntC hashSetC;
				FindByHashTest(hashSetC);

				typedef hash_set<int, hash<int>, equal_to<int>, EASTLAllocatorType, false> HashSetInt;
				HashSetInt hashSet;
				FindByHashTest(hashSet);
			}
		}
		#endif
	}


	{
		// hash_set(const allocator_type& allocator);
		// hashtable& operator=(const this_type& x);
		// bool validate() const;

		hash_set<int> hashSet1(EASTLAllocatorType("hash_set name"));
		hash_set<int> hashSet2(hashSet1);

		for(int i = 0; i < 10; i++)
		{
			hashSet1.insert(i);
			hashSet2.insert(i);
		}

		hashSet1 = hashSet2;

		EATEST_VERIFY(hashSet1.validate());
		EATEST_VERIFY(hashSet2.validate());
	}


	{
		// hash_set(size_type nBucketCount, const Hash& hashFunction = Hash(), const Predicate& predicate = Predicate(), const allocator_type& allocator);
		// hashtable(const hashtable& x);
		// hashtable& operator=(const this_type& x);
		// void swap(this_type& x);
		// bool validate() const;
		{
			hash_set<int> hashSet3(0);
			hash_set<int> hashSet4(1);
			hash_set<int> hashSet5(2);
			hash_set<int> hashSet6(3);
			hash_set<int> hashSet7(4);

			hashSet4 = hashSet3;
			hashSet6 = hashSet5;
			hashSet3 = hashSet7;

			for(int i = 0; i < 10; i++)
			{
				hashSet3.insert(i);
				hashSet4.insert(i);
				hashSet5.insert(i);
				hashSet6.insert(i);
				hashSet7.insert(i);
			}

			hashSet4 = hashSet3;
			hashSet6 = hashSet5;
			hashSet3 = hashSet7;

			EATEST_VERIFY(hashSet3.validate());
			EATEST_VERIFY(hashSet4.validate());
			EATEST_VERIFY(hashSet5.validate());
			EATEST_VERIFY(hashSet6.validate());
			EATEST_VERIFY(hashSet7.validate());

			swap(hashSet4, hashSet3);
			swap(hashSet6, hashSet5);
			swap(hashSet3, hashSet7);

			EATEST_VERIFY(hashSet3.validate());
			EATEST_VERIFY(hashSet4.validate());
			EATEST_VERIFY(hashSet5.validate());
			EATEST_VERIFY(hashSet6.validate());
			EATEST_VERIFY(hashSet7.validate());

			hash_set<int> hashSet8(hashSet6);
			hash_set<int> hashSet9(hashSet7);
			hash_set<int> hashSet10(hashSet8);

			EATEST_VERIFY(hashSet8.validate());
			EATEST_VERIFY(hashSet9.validate());
			EATEST_VERIFY(hashSet10.validate());
		}
		
		// test hashtable::swap using different allocator instances
		{
			typedef hash_set<int, eastl::hash<int>, eastl::equal_to<int>, InstanceAllocator> HS;
			HS hashSet1(InstanceAllocator("hash_set1 name", 111));
			HS hashSet2(InstanceAllocator("hash_set2 name", 222));

			for(int i = 0; i < 10; i++)
			{
				hashSet1.insert(i);
				hashSet2.insert(i+10);
			}

			hashSet2.swap(hashSet1);

			EATEST_VERIFY(hashSet1.validate());
			EATEST_VERIFY(hashSet2.validate());

			EATEST_VERIFY(hashSet1.get_allocator().mInstanceId == 222);
			EATEST_VERIFY(hashSet2.get_allocator().mInstanceId == 111);

			EATEST_VERIFY(eastl::all_of(eastl::begin(hashSet2), eastl::end(hashSet2), [](int i) { return i < 10; }));
			EATEST_VERIFY(eastl::all_of(eastl::begin(hashSet1), eastl::end(hashSet1), [](int i) { return i >= 10; }));
		}
	}


	{
		// hash_set(InputIterator first, InputIterator last, size_type nBucketCount = 8, const Hash& hashFunction = Hash(), const Predicate& predicate = Predicate(), const allocator_type& allocator);
		// bool validate() const;

		vector<int> intArray;
		for(int i = 0; i < 1000; i++)
			intArray.push_back(i);

		hash_set<int> hashSet1(intArray.begin(), intArray.end(), 0);
		hash_set<int> hashSet2(intArray.begin(), intArray.end(), 1);
		hash_set<int> hashSet3(intArray.begin(), intArray.end(), 2);
		hash_set<int> hashSet4(intArray.begin(), intArray.end(), 3);

		EATEST_VERIFY(hashSet1.validate());
		EATEST_VERIFY(hashSet2.validate());
		EATEST_VERIFY(hashSet3.validate());
		EATEST_VERIFY(hashSet4.validate());


		// bool validate_iterator(const_iterator i) const;
		hash_set<int>::iterator it;
		int result = hashSet1.validate_iterator(it);
		EATEST_VERIFY(result == isf_none);

		it = hashSet1.begin();
		result = hashSet2.validate_iterator(it);
		EATEST_VERIFY(result == isf_none);
		result = hashSet1.validate_iterator(it);
		EATEST_VERIFY(result == (isf_valid | isf_current | isf_can_dereference));

		it = hashSet1.end();
		result = hashSet1.validate_iterator(it);
		EATEST_VERIFY(result == (isf_valid | isf_current));


		// void reset_lose_memory();
		hashSet1.reset_lose_memory();
		hashSet1 = hashSet2;

		EATEST_VERIFY(hashSet1.validate());
		EATEST_VERIFY(hashSet2.validate());

		hashSet3.reset_lose_memory();
		hashSet4 = hashSet3;

		EATEST_VERIFY(hashSet3.validate());
		EATEST_VERIFY(hashSet4.validate());

		hashSet2.reset_lose_memory();
		hashSet3.reset_lose_memory();
		swap(hashSet2, hashSet3);

		EATEST_VERIFY(hashSet3.validate());
		EATEST_VERIFY(hashSet4.validate());

		hashSet2 = hashSet3;
		EATEST_VERIFY(hashSet2.validate());
	}


	{
		// void insert(InputIterator first, InputIterator last);
		vector<int> intArray1;
		vector<int> intArray2;

		for(int i = 0; i < 1000; i++)
		{
			intArray1.push_back(i + 0);
			intArray2.push_back(i + 500);
		}

		hash_set<int> hashSet1(intArray1.begin(), intArray1.end());
		hashSet1.insert(intArray2.begin(), intArray2.end());
		EATEST_VERIFY(hashSet1.validate());

		hash_set<int> hashSet2;
		hashSet2.insert(intArray1.begin(), intArray1.end());
		hashSet2.insert(intArray2.begin(), intArray2.end());
		EATEST_VERIFY(hashSet2.validate());

		EATEST_VERIFY(hashSet1 == hashSet2);


		// insert_return_type insert(const_iterator, const value_type& value)
		for(int j = 0; j < 1000; j++)
			hashSet1.insert(hashSet1.begin(), j);

		insert_iterator< hash_set<int> > ii(hashSet1, hashSet1.begin());
		for(int j = 0; j < 1000; j++)
			*ii++ = j;
	}


	{
		// C++11 emplace and related functionality
		nErrorCount += TestMapCpp11<eastl::hash_map<int, TestObject>>();
		nErrorCount += TestMapCpp11<eastl::unordered_map<int, TestObject>>();

		nErrorCount += TestSetCpp11<eastl::hash_set<TestObject>>();
		nErrorCount += TestSetCpp11<eastl::unordered_set<TestObject>>();

		nErrorCount += TestMultimapCpp11<eastl::hash_multimap<int, TestObject>>();
		nErrorCount += TestMultimapCpp11<eastl::unordered_multimap<int, TestObject>>();

		nErrorCount += TestMultisetCpp11<eastl::hash_multiset<TestObject>>();
		nErrorCount += TestMultisetCpp11<eastl::unordered_multiset<TestObject>>();

		nErrorCount += TestMapCpp11NonCopyable<eastl::hash_map<int, NonCopyable>>();
		nErrorCount += TestMapCpp11NonCopyable<eastl::unordered_map<int, NonCopyable>>();
	}

	{
		// C++17 try_emplace and related functionality
		nErrorCount += TestMapCpp17<eastl::hash_map<int, TestObject>>();
		nErrorCount += TestMapCpp17<eastl::unordered_map<int, TestObject>>();
	}


	{
		// initializer_list support.
		// hash_set(std::initializer_list<value_type> ilist, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), 
		//            const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_SET_DEFAULT_ALLOCATOR)
		// this_type& operator=(std::initializer_list<value_type> ilist);
		// void insert(std::initializer_list<value_type> ilist);
		hash_set<int> intHashSet = { 12, 13, 14 };
		EATEST_VERIFY(intHashSet.size() == 3);
		EATEST_VERIFY(intHashSet.find(12) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(13) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(14) != intHashSet.end());

		intHashSet = { 22, 23, 24 };
		EATEST_VERIFY(intHashSet.size() == 3);
		EATEST_VERIFY(intHashSet.find(22) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(23) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(24) != intHashSet.end());

		intHashSet.insert({ 42, 43, 44 });
		EATEST_VERIFY(intHashSet.size() == 6);
		EATEST_VERIFY(intHashSet.find(42) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(43) != intHashSet.end());
		EATEST_VERIFY(intHashSet.find(44) != intHashSet.end());
	}

	{
		// eastl::pair<iterator, iterator>             equal_range(const key_type& k);
		// eastl::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
		// const_iterator  erase(const_iterator, const_iterator);
		// size_type       erase(const key_type&);
		// To do.
	}


	{ // hash_set erase_if
		hash_set<int> m = {0, 1, 2, 3, 4};
		eastl::erase_if(m, [](auto i) { return i % 2 == 0; });
		VERIFY((m == hash_set<int>{1, 3}));
	}

	{ // hash_multiset erase_if
		hash_multiset<int> m = {0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4};
		eastl::erase_if(m, [](auto i) { return i % 2 == 0; });
		VERIFY((m == hash_multiset<int>{1, 1, 1, 3}));
	}






	{   // Test hash_map

		// insert_return_type insert(const value_type& value);
		// insert_return_type insert(const key_type& key);
		// iterator       find(const key_type& k);
		// const_iterator find(const key_type& k) const;

		typedef hash_map<int, int> HashMapIntInt;
		HashMapIntInt hashMap;
		const int kCount = 10000;

		for(int i = 0; i < kCount; i++)
		{
			HashMapIntInt::value_type vt(i, i);
			hashMap.insert(vt);
		}

		const HashMapIntInt const_hashMap = hashMap; // creating a const version to test for const correctness

		for(auto& e : hashMap)
		{
			int k = e.first;
			int v = e.second;
			EATEST_VERIFY(k < kCount);
			EATEST_VERIFY(v == k);
			EATEST_VERIFY(hashMap.at(k) == k);
			EATEST_VERIFY(const_hashMap.at(k) == k);
			hashMap.at(k) = k << 4;
		}

		for(auto& e : hashMap)
		{
			int k = e.first;
			int v = e.second;
			EATEST_VERIFY(k < kCount);
			EATEST_VERIFY(v == (k << 4));
		}

		for(int i = 0; i < kCount * 2; i++)
		{
			HashMapIntInt::iterator it = hashMap.find(i);

			if(i < kCount)
			{
				EATEST_VERIFY(it != hashMap.end());

				int k = (*it).first;
				int v = (*it).second;
				EATEST_VERIFY(v == (k << 4));
			}
			else
				EATEST_VERIFY(it == hashMap.end());
		}

		for(int i = 0; i < kCount; i++)
		{
			int v = hashMap.at(i);
			EATEST_VERIFY(v == (i << 4));
		}

		#if EASTL_EXCEPTIONS_ENABLED
			try
			{
				hashMap.at(kCount);
				EASTL_ASSERT_MSG(false, "at accessor did not throw out_of_range exception");
			}
			catch(const std::out_of_range) { }
			catch(const std::exception& e)
			{
				string e_msg(e.what());
				string msg = "wrong exception with message \"" + e_msg + "\" thrown";
				EASTL_ASSERT_MSG(false, msg.c_str());
			}
		#endif
		HashMapIntInt::insert_return_type result = hashMap.insert(88888);
		EATEST_VERIFY(result.second == true);
		result = hashMap.insert(88888);
		EATEST_VERIFY(result.second == false);
		result.first->second = 0;

		// const_iterator erase(const_iterator);
		size_t nExpectedSize = hashMap.size();

		HashMapIntInt::iterator it50 = hashMap.find(50);
		EATEST_VERIFY(it50 != hashMap.end());

		HashMapIntInt::iterator itNext = hashMap.erase(it50);
		nExpectedSize--;
		EATEST_VERIFY(itNext != hashMap.end()); // Strictly speaking, this isn't guaranteed to be so. But statistically it is very likely. We'll fix this if it becomes a problem.
		EATEST_VERIFY(hashMap.size() == nExpectedSize);

		HashMapIntInt::size_type n = hashMap.erase(10);
		nExpectedSize--;
		EATEST_VERIFY(n == 1);
		EATEST_VERIFY(hashMap.size() == nExpectedSize);

		HashMapIntInt::iterator it60 = hashMap.find(60);
		EATEST_VERIFY(itNext != hashMap.end());

		HashMapIntInt::iterator it60Incremented(it60);
		for(int i = 0; (i < 5) && (it60Incremented != hashMap.end()); ++i)
		{
			++it60Incremented;
			--nExpectedSize;
		}

		hashMap.erase(it60, it60Incremented);
		EATEST_VERIFY(hashMap.size() == nExpectedSize);


		// insert_return_type insert(const value_type& value, hash_code_t c, node_type* pNodeNew = NULL);
		HashMapIntInt::node_type* pNode = hashMap.allocate_uninitialized_node();
		HashMapIntInt::insert_return_type r = hashMap.insert(eastl::hash<int>()(999999), pNode, HashMapIntInt::value_type(999999, 999999));
		EATEST_VERIFY(r.second == true);
		pNode = hashMap.allocate_uninitialized_node();
		r = hashMap.insert(eastl::hash<int>()(999999), pNode, HashMapIntInt::value_type(999999, 999999));
		EATEST_VERIFY(r.second == false);
		hashMap.free_uninitialized_node(pNode);
		hashMap.erase(999999);


		// mapped_type& operator[](const key_type& key)
		// hash_map is unique among the map/set containers in having this function.
		hashMap.clear();

		int x = hashMap[0]; // A default-constructed int (i.e. 0) should be returned.
		EATEST_VERIFY(x == 0); 
   
		hashMap[1] = 1;
		x = hashMap[1];
		EATEST_VERIFY(x == 1);     // Verify that the value we assigned is returned and a default-constructed value is not returned.
	 
		hashMap[0] = 10;    // Overwrite our previous 0 with 10.
		hashMap[1] = 11;
		x = hashMap[0];
		EATEST_VERIFY(x == 10);    // Verify the value is as expected.
		x = hashMap[1];
		EATEST_VERIFY(x == 11);
	}


	{   // Test hash_map

		// Aligned objects should be CustomAllocator instead of the default, because the 
		// EASTL default might be unable to do aligned allocations, but CustomAllocator always can.
		hash_map<Align32, int, eastl::hash<Align32>, eastl::equal_to<Align32>, CustomAllocator> hashMap;
		const int kCount = 10000;

		for(int i = 0; i < kCount; i++)
		{
			Align32 a32(i); // GCC 2.x doesn't like the Align32 object being created in the ctor below.
			hash_map<Align32, int>::value_type vt(a32, i);
			hashMap.insert(vt);
		}

		for(hash_map<Align32, int>::iterator it = hashMap.begin(); it != hashMap.end(); ++it)
		{
			const Align32& k = (*it).first;
			int            v = (*it).second;
			EATEST_VERIFY(k.mX < 10000);
			EATEST_VERIFY(v == k.mX);
		}

		for(int i = 0; i < kCount * 2; i++)
		{
			hash_map<Align32, int>::iterator it = hashMap.find(Align32(i));

			if(i < kCount)
			{
				EATEST_VERIFY(it != hashMap.end());

				const Align32& k = (*it).first;
				int            v = (*it).second;
				EATEST_VERIFY(v == k.mX);
			}
			else
				EATEST_VERIFY(it == hashMap.end());
		}
	}

	{ // hash_map erase_if
		hash_map<int, int> m = {{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}};
		eastl::erase_if(m, [](auto p) { return p.first % 2 == 0; });
		VERIFY((m == hash_map<int, int>{{1, 1}, {3, 3}}));
	}

	{ // hash_multimap erase_if
		hash_multimap<int, int> m = {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {1, 1}, {2, 2},
		                             {2, 2}, {2, 2}, {2, 2}, {3, 3}, {3, 3}, {4, 4}};
		eastl::erase_if(m, [](auto p) { return p.first % 2 == 0; });
		VERIFY((m == hash_multimap<int, int>{{1, 1}, {3, 3}, {3, 3}}));
	}



	{   
		// template <typename U, typename UHash, typename BinaryPredicate>
		// iterator find_as(const U& u, UHash uhash, BinaryPredicate predicate);
		// template <typename U, typename UHash, typename BinaryPredicate>
		// const_iterator find_as(const U& u, UHash uhash, BinaryPredicate predicate) const;
		// template <typename U>
		// iterator find_as(const U& u);
		// template <typename U>
		// const_iterator find_as(const U& u) const;

		typedef hash_set<string> HashSetString;

		HashSetString hashSet;
		const int kCount = 100;

		for(int i = 0; i < kCount; i++)
		{
			string::CtorSprintf cs; // GCC 2.x doesn't like this value being created in the ctor below.
			string s(cs, "%d", i);
			hashSet.insert(s);
		}

		for(int i = 0; i < kCount * 2; i++)
		{
			char pString[32];
			sprintf(pString, "%d", i);

			HashSetString::iterator it = hashSet.find_as(pString);
			if(i < kCount)
				EATEST_VERIFY(it != hashSet.end());
			else
				EATEST_VERIFY(it == hashSet.end());

			it = hashSet.find_as(pString, hash<const char*>(), equal_to_2<string, const char*>());
			if(i < kCount)
				EATEST_VERIFY(it != hashSet.end());
			else
				EATEST_VERIFY(it == hashSet.end());
		}
	}

	{
		// Test const containers.
		const hash_set<int> constHashSet;

		hash_set<int>::const_iterator i = constHashSet.begin();
		hash_set<int>::const_iterator i3 = i;
		hash_set<int>::iterator i2;
		i3 = i2;

		EATEST_VERIFY(i3 == i2);

		//const std::tr1::unordered_set<int> constUSet;
		//std::tr1::unordered_set<int>::const_iterator i = constUSet.begin();
		//*i = 0;
	}

	{
		// global operator ==, !=
		EASTLTest_Rand rng(EA::UnitTest::GetRandSeed());
		const eastl_size_t kIterationCount = 100;
		const eastl_size_t kDataRange = 50;

		{
			typedef hash_set<HashtableValue, HashtableValueHash, HashtableValuePredicate> HashSet;
			HashtableValue value;

			HashSet h1;
			HashSet h2;
			EATEST_VERIFY(h1 == h2);

			for(eastl_size_t i = 0; i < kIterationCount; i++)
			{
				value.mData = rng.RandLimit(kDataRange);
				h1.insert(value);  // Leave value.mExtra as 0.
			}

			EATEST_VERIFY(h1 != h2);
			h2 = h1;
			EATEST_VERIFY(h1 == h2);

			// Test the case of the containers being the same size but having a single different value, despite that it's key compare yields equal.
			HashSet h2Saved(h2);
			HashSet::iterator it = h2.find(value);
			HashtableValue valueModified(value.mData, 1);
			h2.erase(it);
			h2.insert(valueModified);
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			// Test the case of the containers being the same size but having a single different key.
			h2Saved = h2;
			h2.erase(h2.find(value));
			h2.insert(kDataRange); // Insert something that could not have been in h2.
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			h1.erase(h1.find(value)); // Erase from h1 whatever the last value was.
			EATEST_VERIFY(h1 != h2);
		}

		{
			typedef hash_multiset<HashtableValue, HashtableValueHash, HashtableValuePredicate> HashSet;
			HashtableValue value;

			HashSet h1;
			HashSet h2;
			EATEST_VERIFY(h1 == h2);

			for(eastl_size_t i = 0; i < kIterationCount; i++)
			{
				value.mData = rng.RandLimit(kDataRange);
				h1.insert(value);  // Leave value.mExtra as 0.
			}

			EATEST_VERIFY(h1 != h2);
			h2 = h1;
			EATEST_VERIFY(h1 == h2);

			// Test the case of the containers being the same size but having a single different value, despite that it's key compare yields equal.
			HashSet h2Saved(h2);
			HashSet::iterator it = h2.find(value);
			HashtableValue valueModified(value.mData, 1);
			h2.erase(it);
			h2.insert(valueModified);
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			// Test the case of the containers being the same size but having a single different key.
			h2Saved = h2;
			h2.erase(h2.find(value));
			h2.insert(kDataRange); // Insert something that could not have been in h2.
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			h1.erase(h1.find(value)); // Erase from h1 whatever the last value was.
			EATEST_VERIFY(h1 != h2);
		}

		{
			// For simplicity we duplicate the HashtableValue::mData member as the hash map key.
			typedef hash_map<eastl_size_t, HashtableValue, HashtableValueHash, HashtableValuePredicate> HashMap;
			HashtableValue value;

			HashMap h1;
			HashMap h2;
			EATEST_VERIFY(h1 == h2);

			for(eastl_size_t i = 0; i < kIterationCount; i++)
			{
				value.mData = rng.RandLimit(kDataRange);
				h1.insert(HashMap::value_type(value.mData, value));  // Leave value.mExtra as 0.
			}

			EATEST_VERIFY(h1 != h2);
			h2 = h1;
			EATEST_VERIFY(h1 == h2);

			// Test the case of the containers being the same size but having a single different value, despite that it's key compare yields equal.
			HashMap h2Saved(h2);
			HashMap::iterator it = h2.find(value.mData); // We are using value.mData as the key as well, so we can do a find via it.
			HashtableValue valueModified(value.mData, 1);
			h2.erase(it);
			h2.insert(HashMap::value_type(valueModified.mData, valueModified));
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			// Test the case of the containers being the same size but having a single different key.
			h2Saved = h2;
			h2.erase(h2.find(value.mData));
			h2.insert(HashMap::value_type(kDataRange, HashtableValue(kDataRange))); // Insert something that could not have been in h2.
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			h1.erase(h1.find(value.mData)); // Erase from h1 whatever the last value was.
			EATEST_VERIFY(h1 != h2);
		}

		{
			// For simplicity we duplicate the HashtableValue::mData member as the hash map key.
			typedef hash_multimap<eastl_size_t, HashtableValue, HashtableValueHash, HashtableValuePredicate> HashMap;
			HashtableValue value;

			HashMap h1;
			HashMap h2;
			EATEST_VERIFY(h1 == h2);

			for(eastl_size_t i = 0; i < kIterationCount; i++)
			{
				value.mData = rng.RandLimit(kDataRange);
				h1.insert(HashMap::value_type(value.mData, value));  // Leave value.mExtra as 0.
			}

			EATEST_VERIFY(h1 != h2);
			h2 = h1;
			EATEST_VERIFY(h1 == h2);

			// Test the case of the containers being the same size but having a single different value, despite that it's key compare yields equal.
			HashMap h2Saved(h2);
			HashMap::iterator it = h2.find(value.mData); // We are using value.mData as the key as well, so we can do a find via it.
			HashtableValue valueModified(value.mData, 1);
			h2.erase(it);
			h2.insert(HashMap::value_type(valueModified.mData, valueModified));
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			// Test the case of the containers being the same size but having a single different key.
			h2Saved = h2;
			h2.erase(h2.find(value.mData));
			h2.insert(HashMap::value_type(kDataRange, HashtableValue(kDataRange))); // Insert something that could not have been in h2.
			EATEST_VERIFY(h1 != h2);
			h2 = h2Saved;

			h1.erase(h1.find(value.mData)); // Erase from h1 whatever the last value was.
			EATEST_VERIFY(h1 != h2);
		}
	}

	{
		typedef eastl::hash_multiset<int> HashMultisetInt;

		HashMultisetInt hashMultiSet;

		// insert_return_type insert(const value_type& value, hash_code_t c, node_type* pNodeNew = NULL);
		HashMultisetInt::node_type* pNode = hashMultiSet.allocate_uninitialized_node();
		HashMultisetInt::iterator it1 = hashMultiSet.insert(eastl::hash<int>()(999999), pNode, 999999);
		EATEST_VERIFY(it1 != hashMultiSet.end());
		pNode = hashMultiSet.allocate_uninitialized_node();
		HashMultisetInt::iterator it2 = hashMultiSet.insert(eastl::hash<int>()(999999), pNode, 999999);
		EATEST_VERIFY(it2 != hashMultiSet.end() && it2 != it1);
	}

	{ 
		// Regression of compiler warning reported by Jeff Litz/Godfather regarding 
		// strict aliasing (EASTL 1.09.01) December 2007).
		typedef eastl::hash_multimap<uint32_t, uint32_t*> Map;
		Map* pMap = new Map;
		delete pMap;
	}

	{ 
		// Regression of user-reported crash.
		eastl::hash_map<int, eastl::string*>* _hmTextureList;
		_hmTextureList = new eastl::hash_map<int, eastl::string*>();
		eastl::string* a = NULL;
		(*_hmTextureList)[0] = a;
		delete _hmTextureList;
	}

	{
		// Regression of user-reported Android compiler error.
		typedef eastl::hash_multimap<HashRegressionA*, HashRegressionB> HMM;
		HMM m_hash;

		// Section 1
		for (HMM::iterator it = m_hash.begin(); it != m_hash.end(); it++)
			it->second.y = 1;

		// Section 2
		HashRegressionA* pA = NULL;
		eastl::pair<HMM::iterator, HMM::iterator> pair = m_hash.equal_range(pA);
		(void)pair;
	}

	{
		// Regression of user-reported GCC 4.8 compile failure.
		typedef eastl::hash_map<int64_t, Struct> AuditByBlazeIdMap;

		AuditByBlazeIdMap auditBlazeIds;
		AuditByBlazeIdMap tempAuditBlazeIds;

		auditBlazeIds.swap(tempAuditBlazeIds); // This line was generating an unexpected compiler failure.
		EATEST_VERIFY(auditBlazeIds.empty() && tempAuditBlazeIds.empty());
	}

	{
		// This test is designed to designed to use the find_range_by_hash method to walk over all keys in a hash bucket (located by a hash value).
		
		// Use the 'colliding_hash' hash function to intentionally create lots of collisions in a predictable way.
		typedef hash_map<int, int, colliding_hash> HM;
		HM hashMap;

		// Add some numbers to the hashMap.
		for(int i=0; i<90; i++)
		{
			hashMap[i] = i;
		}

		// Try to find a hash value that doesn't exist
		{
			eastl::pair<HM::iterator, HM::iterator> i = hashMap.find_range_by_hash(1000);
			EATEST_VERIFY(i.first == hashMap.end());
			EATEST_VERIFY(i.second == hashMap.end());
		}

		{
			int iterations = 0;
			for(eastl::pair<HM::iterator, HM::iterator> i = hashMap.find_range_by_hash(1); i.first != i.second; i.first++)
			{
				int nodeValue = i.first.get_node()->mValue.first;
				EATEST_VERIFY(nodeValue % 3 == 1);   // Verify the hash of the node matches the expected value
				iterations++;
			}
			EATEST_VERIFY(iterations == 30);
		}

		{
			const HM &constHashMap = hashMap;
			int iterations = 0;
			for(eastl::pair<HM::const_iterator, HM::const_iterator> i = constHashMap.find_range_by_hash(1); i.first != i.second; i.first++)
			{
				int nodeValue = i.first.get_node()->mValue.first;
				EATEST_VERIFY(nodeValue % 3 == 1);   // Verify the hash of the node matches the expected value
				iterations++;
			}
			EATEST_VERIFY(iterations == 30);
		}
	}

	// test hashtable holding move-only types
	#if !defined(EA_COMPILER_MSVC_2013)
	{
		struct Movable
		{
			Movable() {}
			Movable(Movable&&) = default;
			Movable& operator=(Movable&&) = default;
			Movable(const Movable&) = delete;
			Movable& operator=(const Movable&) = delete;

			bool operator==(Movable) const { return true; }

			struct Hash
			{
				size_t operator()(Movable) const { return 0; }
			};
		};

		eastl::unordered_set<Movable, Movable::Hash> a, b;
		swap(a,b);
	}
	#endif

	{
		// hashtable(this_type&& x);
		// hashtable(this_type&& x, const allocator_type& allocator);
		// this_type& operator=(this_type&& x);

		// template <class... Args>
		// insert_return_type emplace(Args&&... args);

		// template <class... Args>
		// iterator emplace_hint(const_iterator position, Args&&... args);

		// template <class P> // Requires that "value_type is constructible from forward<P>(otherValue)."
		// insert_return_type insert(P&& otherValue);

		// iterator insert(const_iterator hint, value_type&& value);

		// Regression of user reported compiler error in hashtable sfinae mechanism 
		{
			TestObject::Reset();
			eastl::hash_set<TestObject> toSet;
			toSet.emplace(3, 4, 5);
		}
	}



	{
		// initializer_list support.
		// hash_map(std::initializer_list<value_type> ilist, size_type nBucketCount = 0, const Hash& hashFunction = Hash(), 
		//            const Predicate& predicate = Predicate(), const allocator_type& allocator = EASTL_HASH_MAP_DEFAULT_ALLOCATOR)
		// this_type& operator=(std::initializer_list<value_type> ilist);
		// void insert(std::initializer_list<value_type> ilist);
		
		// VS2013 has a known issue when dealing with std::initializer_lists
		// https://connect.microsoft.com/VisualStudio/feedback/details/792355/compiler-confused-about-whether-to-use-a-initializer-list-assignment-operator
		#if !defined(EA_COMPILER_NO_INITIALIZER_LISTS) && !(defined(_MSC_VER) && _MSC_VER == 1800)
			hash_map<int, double> intHashMap = { {12,12.0}, {13,13.0}, {14,14.0} };
			EATEST_VERIFY(intHashMap.size() == 3);
			EATEST_VERIFY(intHashMap.find(12) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(13) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(14) != intHashMap.end());

			intHashMap = { {22,22.0}, {23,23.0}, {24,24.0} };
			EATEST_VERIFY(intHashMap.size() == 3);
			EATEST_VERIFY(intHashMap.find(22) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(23) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(24) != intHashMap.end());

			intHashMap.insert({ {42,42.0}, {43,43.0}, {44,44.0} });
			EATEST_VERIFY(intHashMap.size() == 6);
			EATEST_VERIFY(intHashMap.find(42) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(43) != intHashMap.end());
			EATEST_VERIFY(intHashMap.find(44) != intHashMap.end());
		#endif
	}

	// Can't use move semantics with hash_map::operator[]
	//
	// GCC has a bug with overloading rvalue and lvalue function templates.
	// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54425
	// 
	// error: 'eastl::pair<T1, T2>::pair(T1&&) [with T1 = const int&; T2 = const int&]' cannot be overloaded
	// error: with 'eastl::pair<T1, T2>::pair(const T1&) [with T1 = const int&; T2 = const int&]'
	#if !defined(EA_COMPILER_GNUC)
	{
		EA_DISABLE_VC_WARNING(4626)
		struct Key
		{
			Key() {}
			Key(Key&&) {}
			Key(const Key&&) {}
			bool operator==(const Key&) const { return true; }

		private:
			Key(const Key&) {}
		};
		EA_RESTORE_VC_WARNING()

		struct Hash
		{
			std::size_t operator()(const Key&) const { return 0; }
		};

		Key key1, key2;
		eastl::hash_map<Key, int, Hash> hm;
		hm[eastl::move(key1)] = 12345;

		EATEST_VERIFY(hm[eastl::move(key2)] == 12345);
	}
	#endif

	{
		using AllocatorType = CountingAllocator;
		using String = eastl::basic_string<char8_t, AllocatorType>;
		using StringStringMap = eastl::map<String, String, eastl::equal_to<String>, AllocatorType>;
		using StringStringHashMap = eastl::hash_map<String, String, eastl::string_hash<String>, eastl::equal_to<String>, AllocatorType>;
		AllocatorType::resetCount();

		{
			StringStringHashMap myMap(5); // construct map with 5 buckets, so we don't rehash on insert
			String key("mykey01234567890000000000000000000000000000");
			String value("myvalue01234567890000000000000000000000000000");
			AllocatorType::resetCount();

			myMap.insert(eastl::make_pair(eastl::move(key), eastl::move(value)));
			EATEST_VERIFY(AllocatorType::getTotalAllocationCount() == 1);
		}
		{
			StringStringHashMap myMap(5); // construct map with 5 buckets, so we don't rehash on insert
			String key("mykey01234567890000000000000000000000000000");
			String value("myvalue01234567890000000000000000000000000000");
			AllocatorType::resetCount();

			myMap.emplace(eastl::move(key), eastl::move(value));
			EATEST_VERIFY(AllocatorType::getTotalAllocationCount() == 1);
		}
		{
			StringStringMap myMap;
			String key("mykey01234567890000000000000000000000000000");
			String value("myvalue01234567890000000000000000000000000000");
			AllocatorType::resetCount();

			myMap.insert(eastl::make_pair(eastl::move(key), eastl::move(value)));
			EATEST_VERIFY(AllocatorType::getTotalAllocationCount() == 1);
		}
		{
			StringStringMap myMap;
			String key("mykey01234567890000000000000000000000000000");
			String value("myvalue01234567890000000000000000000000000000");
			AllocatorType::resetCount();

			myMap.emplace(eastl::move(key), eastl::move(value));
			EATEST_VERIFY(AllocatorType::getTotalAllocationCount() == 1);
		}
	}

	
	{
		struct name_equals
		{
			bool operator()(const eastl::pair<int, const char*>& a, const eastl::pair<int, const char*>& b) const
			{
				if (a.first != b.first)
					return false;

				return strcmp(a.second, b.second) == 0;
			}
		};

		{
			int n = 42;
			const char* pCStrName = "electronic arts";
			eastl::hash_map<eastl::pair<int, const char*>, bool, eastl::hash<eastl::pair<int, const char*>>, name_equals, eastl::allocator> m_TempNames;
			m_TempNames[eastl::make_pair(n, pCStrName)] = true;

			auto isFound = (m_TempNames.find(eastl::make_pair(n, pCStrName)) != m_TempNames.end());
			VERIFY(isFound);
		}
	}

	{ // User reported regression for code changes limiting hash code generated for non-arithmetic types.
	    { VERIFY(HashTest<char>{}('a') == size_t('a')); }
	    { VERIFY(HashTest<int>{}(42) == 42); }
	    { VERIFY(HashTest<unsigned>{}(42) == 42); }
	    { VERIFY(HashTest<signed>{}(42) == 42); }
	    { VERIFY(HashTest<short>{}(short(42)) == 42); }
	    { VERIFY(HashTest<unsigned short>{}((unsigned short)42) == 42); }
	    { VERIFY(HashTest<int>{}(42) == 42); }
	    { VERIFY(HashTest<unsigned int>{}(42) == 42); }
	    { VERIFY(HashTest<long int>{}(42) == 42); }
	    { VERIFY(HashTest<unsigned long int>{}(42) == 42); }
	    { VERIFY(HashTest<long long int>{}(42) == 42); }
	    { VERIFY(HashTest<unsigned long long int>{}(42) == 42); }

	#if defined(EA_HAVE_INT128) && EA_HAVE_INT128
	    { VERIFY(HashTest<uint128_t>{}(UINT128_C(0, 42)) == 42); }
	#endif
    }

	return nErrorCount;
}