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


#ifndef EASTLTEST_H
#define EASTLTEST_H


#include <EABase/eabase.h>
#include <EATest/EATest.h>

EA_DISABLE_ALL_VC_WARNINGS()
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <vector>   // For the STD_STL_TYPE defines below.
#if EASTL_EXCEPTIONS_ENABLED
	#include <stdexcept>
	#include <new>
#endif
EA_RESTORE_ALL_VC_WARNINGS();


int TestAlgorithm();
int TestAllocator();
int TestAny();
int TestArray();
int TestBitVector();
int TestBitset();
int TestCharTraits();
int TestChrono();
int TestCppCXTypeTraits();
int TestDeque();
int TestExtra();
int TestFinally();
int TestFixedFunction();
int TestFixedHash();
int TestFixedList();
int TestFixedMap();
int TestFixedSList();
int TestFixedSet();
int TestFixedString();
int TestFixedTupleVector();
int TestFixedVector();
int TestFunctional();
int TestHash();
int TestHeap();
int TestIntrusiveHash();
int TestIntrusiveList();
int TestIntrusiveSDList();
int TestIntrusiveSList();
int TestIterator();
int TestList();
int TestListMap();
int TestLruCache();
int TestMap();
int TestMemory();
int TestMeta();
int TestNumericLimits();
int TestOptional();
int TestRandom();
int TestRatio();
int TestRingBuffer();
int TestSList();
int TestSegmentedVector();
int TestSet();
int TestSmartPtr();
int TestSort();
int TestSpan();
int TestString();
int TestStringHashMap();
int TestStringMap();
int TestStringView();
int TestTuple();
int TestTupleVector();
int TestTypeTraits();
int TestUtility();
int TestVariant();
int TestVector();
int TestVectorMap();
int TestVectorSet();
int TestAtomicBasic();
int TestAtomicAsm();


// Now enable warnings as desired.
#ifdef _MSC_VER
	#pragma warning(disable: 4324)      // 'struct_name' : structure was padded due to __declspec(align())
  //#pragma warning(disable: 4512)      // 'class' : assignment operator could not be generated
  //#pragma warning(disable: 4100)      // 'identifier' : unreferenced formal parameter
  //#pragma warning(disable: 4706)      // assignment within conditional expression

	#pragma warning(default: 4056)      // Floating-point constant arithmetic generates a result that exceeds the maximum allowable value
	#pragma warning(default: 4061)      // The enumerate has no associated handler in a switch statement
	#pragma warning(default: 4062)      // The enumerate has no associated handler in a switch statement, and there is no default label
	#pragma warning(default: 4191)      // Calling this function through the result pointer may cause your program to crash
	#pragma warning(default: 4217)      // Member template functions cannot be used for copy-assignment or copy-construction
  //#pragma warning(default: 4242)      // 'variable' : conversion from 'type' to 'type', possible loss of data
	#pragma warning(default: 4254)      // 'operator' : conversion from 'type1' to 'type2', possible loss of data
	#pragma warning(default: 4255)      // 'function' : no function prototype given: converting '()' to '(void)'
	#pragma warning(default: 4263)      // 'function' : member function does not override any base class virtual member function
	#pragma warning(default: 4264)      // 'virtual_function' : no override available for virtual member function from base 'class'; function is hidden
	#pragma warning(default: 4287)      // 'operator' : unsigned/negative constant mismatch
	#pragma warning(default: 4289)      // Nonstandard extension used : 'var' : loop control variable declared in the for-loop is used outside the for-loop scope
	#pragma warning(default: 4296)      // 'operator' : expression is always false
	#pragma warning(default: 4302)      // 'conversion' : truncation from 'type 1' to 'type 2'
	#pragma warning(default: 4339)      // 'type' : use of undefined type detected in CLR meta-data - use of this type may lead to a runtime exception
	#pragma warning(default: 4347)      // Behavior change: 'function template' is called instead of 'function'
  //#pragma warning(default: 4514)      // unreferenced inline/local function has been removed
	#pragma warning(default: 4529)      // 'member_name' : forming a pointer-to-member requires explicit use of the address-of operator ('&') and a qualified name
	#pragma warning(default: 4545)      // Expression before comma evaluates to a function which is missing an argument list
	#pragma warning(default: 4546)      // Function call before comma missing argument list
	#pragma warning(default: 4547)      // 'operator' : operator before comma has no effect; expected operator with side-effect
  //#pragma warning(default: 4548)      // expression before comma has no effect; expected expression with side-effect
	#pragma warning(default: 4549)      // 'operator' : operator before comma has no effect; did you intend 'operator'?
	#pragma warning(default: 4536)      // 'type name' : type-name exceeds meta-data limit of 'limit' characters
	#pragma warning(default: 4555)      // Expression has no effect; expected expression with side-effect
	#pragma warning(default: 4557)      // '__assume' contains effect 'effect'
  //#pragma warning(default: 4619)      // #pragma warning : there is no warning number 'number'
	#pragma warning(default: 4623)      // 'derived class' : default constructor could not be generated because a base class default constructor is inaccessible
  //#pragma warning(default: 4625)      // 'derived class' : copy constructor could not be generated because a base class copy constructor is inaccessible
  //#pragma warning(default: 4626)      // 'derived class' : assignment operator could not be generated because a base class assignment operator is inaccessible
	#pragma warning(default: 4628)      // Digraphs not supported with -Ze. Character sequence 'digraph' not interpreted as alternate token for 'char'
	#pragma warning(default: 4640)      // 'instance' : construction of local static object is not thread-safe
	#pragma warning(default: 4668)      // 'symbol' is not defined as a preprocessor macro, replacing with '0' for 'directives'
	#pragma warning(default: 4682)      // 'parameter' : no directional parameter attribute specified, defaulting to [in]
	#pragma warning(default: 4686)      // 'user-defined type' : possible change in behavior, change in UDT return calling convention
  //#pragma warning(default: 4710)      // 'function' : function not inlined
  //#pragma warning(default: 4786)      // 'identifier' : identifier was truncated to 'number' characters in the debug information
	#pragma warning(default: 4793)      // Native code generated for function 'function': 'reason'
  //#pragma warning(default: 4820)      // 'bytes' bytes padding added after member 'member'
	#pragma warning(default: 4905)      // Wide string literal cast to 'LPSTR'
	#pragma warning(default: 4906)      // String literal cast to 'LPWSTR'
	#pragma warning(default: 4917)      // 'declarator' : a GUID cannot only be associated with a class, interface or namespace
	#pragma warning(default: 4928)      // Illegal copy-initialization; more than one user-defined conversion has been implicitly applied
	#pragma warning(default: 4931)      // We are assuming the type library was built for number-bit pointers
	#pragma warning(default: 4946)      // reinterpret_cast used between related classes: 'class1' and 'class2'

#endif


///////////////////////////////////////////////////////////////////////////////
// EASTL includes
//
// Intentionally keep these includes below the warning settings specified above.
//
#include <EASTL/iterator.h>
#include <EASTL/algorithm.h>




/// EASTL_TestLevel
///
/// Defines how extensive our testing is. A low level is for a desktop or 
/// nightly build in which the test can run quickly but still hit the 
/// majority of functionality. High level is for heavy testing and internal
/// validation which may take numerous hours to run.
///
enum EASTL_TestLevel
{
	kEASTL_TestLevelLow  = 1,   /// ~10 seconds for test completion.
	kEASTL_TestLevelHigh = 10   /// Numerous hours for test completion.
};

extern int gEASTL_TestLevel;



/// EASTLTest_CheckMemory
///
/// Does a global memory heap validation check. Returns 0 if OK and 
/// an error count if there is a problem. 
///
/// Example usage:
///    EASTLTest_CheckMemory();
///
int EASTLTest_CheckMemory_Imp(const char* pFile, int nLine);
#define EASTLTest_CheckMemory() EASTLTest_CheckMemory_Imp(__FILE__, __LINE__)



// EASTLTEST_STD_STL_VER
//
#if defined(_STLPORT_VERSION)
	#define EASTLTEST_STD_STL_VER_STLPORT
#elif defined(_RWSTD_VER_STR) || defined(_RWSTD_NAMESPACE_END)
	#define EASTLTEST_STD_STL_VER_APACHE
#elif defined(_CPPLIB_VER)
	#define EASTLTEST_STD_STL_VER_DINKUMWARE
#elif defined(__GNUC__) && defined(_CXXCONFIG)
	#define EASTLTEST_STD_STL_VER_GCC
#else
	#define EASTLTEST_STD_STL_VER_UNKNOWN
#endif



/// StdSTLType
///
enum StdSTLType
{
	kSTLUnknown,    // Unknown type
	kSTLPort,       // STLPort. Descendent of the old HP / SGI STL.
	kSTLApache,     // Apache stdcxx (previously RogueWave), which is a descendent of the old HP / SGI STL.
	kSTLClang,      // Clang native. a.k.a. libc++
	kSTLGCC,        // GCC native. a.k.a. libstdc++
	kSTLMS,         // Microsoft. Tweaked version of Dinkumware.
	kSTLDinkumware  // Generic Dinkumware
};

StdSTLType GetStdSTLType();




/// GetStdSTLName
///
/// Returns the name of the std C++ STL available to the current build.
/// The returned value will be one of:
///     "STLPort"
///     "GCC"
///     "VC++"
//      "Apache" // Previously RogueWave
///
const char* GetStdSTLName();


/// gEASTLTest_AllocationCount
///
extern int gEASTLTest_AllocationCount; 
extern int gEASTLTest_TotalAllocationCount; 



// For backwards compatibility:
#define EASTLTest_Printf EA::UnitTest::Report
#define VERIFY           EATEST_VERIFY


///////////////////////////////////////////////////////////////////////////////
/// EASTLTest_Rand
///
/// Implements a basic random number generator for EASTL unit tests. It's not
/// intended to be a robust random number generator (though it is decent), 
/// but rather is present so the unit tests can have a portable random number
/// generator they can rely on being present.
///
/// Example usage:
///    EASTLTest_Rand rng;
///    eastl_size_t   x = rng();                      // Generate value in range of [0, 0xffffffff] (i.e. generate any uint32_t)
///    eastl_ssize_t  y = rng.Rand(1000);             // Generate value in range of [0, 1000)
///    eastl_ssize_t  z = rng.RandRange(-50, +30);    // Generate value in range of [-50, +30)
///
/// Example usage in the random_shuffle algorithm:
///    EASTLTest_Rand rng;
///    random_shuffle(first, last, rnd);
///
class EASTLTest_Rand
{
public:
	EASTLTest_Rand(eastl_size_t nSeed) // The user must supply a seed; we don't provide default values.
		: mnSeed(nSeed) { }

	eastl_size_t Rand()
	{
		// This is not designed to be a high quality random number generator.
		if(mnSeed == 0)
			mnSeed = UINT64_C(0xfefefefefefefefe); // Can't have a seed of zero.

		const uint64_t nResult64A = ((mnSeed     * UINT64_C(6364136223846793005)) + UINT64_C(1442695040888963407));
		const uint64_t nResult64B = ((nResult64A * UINT64_C(6364136223846793005)) + UINT64_C(1442695040888963407));

		mnSeed = (nResult64A >> 32) ^ nResult64B;

		return (eastl_size_t)mnSeed; // For eastl_size_t == uint32_t, this is a chop.
	}

	eastl_size_t operator()() // Returns a pseudorandom value in range of [0, 0xffffffffffffffff)] (i.e. generate any eastl_size_t)
		{ return Rand(); }

	eastl_size_t operator()(eastl_size_t n)  // Returns a pseudorandom value in range of [0, n)
		{ return RandLimit(n); }

	eastl_size_t RandLimit(eastl_size_t nLimit) // Returns a pseudorandom value in range of [0, nLimit)
	{
		// Can't do the following correct solution because we don't have a portable int128_t to work with. 
		// We could implement a 128 bit multiply manually. See EAStdC/int128_t.cpp.
		// return (eastl_size_t)((Rand() * (uint128_t)nLimit) >> 64);

		return (Rand() % nLimit); // This results in an imperfect distribution, especially for the case of nLimit being high relative to eastl_size_t.
	}

	eastl_ssize_t RandRange(eastl_ssize_t nBegin, eastl_ssize_t nEnd)   // Returns a pseudorandom value in range of [nBegin, nEnd)
		{ return nBegin + (eastl_ssize_t)RandLimit((eastl_size_t)(nEnd - nBegin)); }

protected:
	uint64_t mnSeed;
};


///////////////////////////////////////////////////////////////////////////////
/// RandGenT
///
/// A wrapper for EASTLTest_Rand which generates values of the given integral
/// data type. This is mostly useful for clearnly avoiding compiler warnings, 
/// as we intentionally enable the highest warning levels in these tests.
///
template <typename Integer>
struct RandGenT
{
	RandGenT(eastl_size_t nSeed)
		: mRand(nSeed) { }

	Integer operator()()
		{ return (Integer)mRand.Rand(); }

	Integer operator()(eastl_size_t n)
		{ return (Integer)mRand.RandLimit(n); }

	EASTLTest_Rand mRand;
};



///////////////////////////////////////////////////////////////////////////////
/// kMagicValue
///
/// Used as a unique integer. We assign this to TestObject in its constructor
/// and verify in the TestObject destructor that the value is unchanged. 
/// This can be used to tell, for example, if an invalid object is being 
/// destroyed.
///
const uint32_t kMagicValue = 0x01f1cbe8;


///////////////////////////////////////////////////////////////////////////////
/// TestObject
///
/// Implements a generic object that is suitable for use in container tests.
/// Note that we choose a very restricted set of functions that are available
/// for this class. Do not add any additional functions, as that would 
/// compromise the intentions of the unit tests.
///
struct TestObject
{
	int             mX;                  // Value for the TestObject.
	bool            mbThrowOnCopy;       // Throw an exception of this object is copied, moved, or assigned to another.
	int64_t         mId;                 // Unique id for each object, equal to its creation number. This value is not coped from other TestObjects during any operations, including moves.
	uint32_t        mMagicValue;         // Used to verify that an instance is valid and that it is not corrupted. It should always be kMagicValue.
	static int64_t  sTOCount;            // Count of all current existing TestObjects.
	static int64_t  sTOCtorCount;        // Count of times any ctor was called.
	static int64_t  sTODtorCount;        // Count of times dtor was called.
	static int64_t  sTODefaultCtorCount; // Count of times the default ctor was called.
	static int64_t  sTOArgCtorCount;     // Count of times the x0,x1,x2 ctor was called.
	static int64_t  sTOCopyCtorCount;    // Count of times copy ctor was called.
	static int64_t  sTOMoveCtorCount;    // Count of times move ctor was called.
	static int64_t  sTOCopyAssignCount;  // Count of times copy assignment was called.
	static int64_t  sTOMoveAssignCount;  // Count of times move assignment was called.
	static int      sMagicErrorCount;    // Number of magic number mismatch errors.

	explicit TestObject(int x = 0, bool bThrowOnCopy = false)
		: mX(x), mbThrowOnCopy(bThrowOnCopy), mMagicValue(kMagicValue)
	{
		++sTOCount;
		++sTOCtorCount;
		++sTODefaultCtorCount;
		mId = sTOCtorCount;
	}

	// This constructor exists for the purpose of testing variadiac template arguments, such as with the emplace container functions.
	TestObject(int x0, int x1, int x2, bool bThrowOnCopy = false)
		: mX(x0 + x1 + x2), mbThrowOnCopy(bThrowOnCopy), mMagicValue(kMagicValue)
	{
		++sTOCount;
		++sTOCtorCount;
		++sTOArgCtorCount;
		mId = sTOCtorCount;
	}

	TestObject(const TestObject& testObject)
		: mX(testObject.mX), mbThrowOnCopy(testObject.mbThrowOnCopy), mMagicValue(testObject.mMagicValue)
	{
		++sTOCount;
		++sTOCtorCount;
		++sTOCopyCtorCount;
		mId = sTOCtorCount;
		if(mbThrowOnCopy)
		{
			#if EASTL_EXCEPTIONS_ENABLED
				throw "Disallowed TestObject copy";
			#endif
		}
	}

	// Due to the nature of TestObject, there isn't much special for us to 
	// do in our move constructor. A move constructor swaps its contents with 
	// the other object, whhich is often a default-constructed object.
	TestObject(TestObject&& testObject)
		: mX(testObject.mX), mbThrowOnCopy(testObject.mbThrowOnCopy), mMagicValue(testObject.mMagicValue)
	{
		++sTOCount;
		++sTOCtorCount;
		++sTOMoveCtorCount;
		mId = sTOCtorCount;  // testObject keeps its mId, and we assign ours anew.
		testObject.mX = 0;   // We are swapping our contents with the TestObject, so give it our "previous" value.
		if(mbThrowOnCopy)
		{
			#if EASTL_EXCEPTIONS_ENABLED
				throw "Disallowed TestObject copy";
			#endif
		}
	}

	TestObject& operator=(const TestObject& testObject)
	{
		++sTOCopyAssignCount;

		if(&testObject != this)
		{
			mX = testObject.mX;
			// Leave mId alone.
			mMagicValue = testObject.mMagicValue;
			mbThrowOnCopy = testObject.mbThrowOnCopy;
			if(mbThrowOnCopy)
			{
				#if EASTL_EXCEPTIONS_ENABLED
					throw "Disallowed TestObject copy";
				#endif
			}
		}
		return *this;
	}

	TestObject& operator=(TestObject&& testObject)
	{
		++sTOMoveAssignCount;

		if(&testObject != this)
		{
			eastl::swap(mX, testObject.mX);
			// Leave mId alone.
			eastl::swap(mMagicValue, testObject.mMagicValue);
			eastl::swap(mbThrowOnCopy, testObject.mbThrowOnCopy);

			if(mbThrowOnCopy)
			{
				#if EASTL_EXCEPTIONS_ENABLED
					throw "Disallowed TestObject copy";
				#endif
			}
		}
		return *this;
	}

	~TestObject()
	{
		if(mMagicValue != kMagicValue)
			++sMagicErrorCount;
		mMagicValue = 0;
		--sTOCount;
		++sTODtorCount;
	}

	static void Reset()
	{
		sTOCount            = 0;
		sTOCtorCount        = 0;
		sTODtorCount        = 0;
		sTODefaultCtorCount = 0;
		sTOArgCtorCount     = 0;
		sTOCopyCtorCount    = 0;
		sTOMoveCtorCount    = 0;
		sTOCopyAssignCount  = 0;
		sTOMoveAssignCount  = 0;
		sMagicErrorCount    = 0;
	}

	static bool IsClear() // Returns true if there are no existing TestObjects and the sanity checks related to that test OK.
	{
		return (sTOCount == 0) && (sTODtorCount == sTOCtorCount) && (sMagicErrorCount == 0);
	}
};

// Operators
// We specifically define only == and <, in order to verify that 
// our containers and algorithms are not mistakenly expecting other 
// operators for the contained and manipulated classes.
inline bool operator==(const TestObject& t1, const TestObject& t2)
	{ return t1.mX == t2.mX; }

inline bool operator<(const TestObject& t1, const TestObject& t2)
	{ return t1.mX < t2.mX; }


// TestObject hash
// Normally you don't want to put your hash functions in the eastl namespace, as that namespace is owned by EASTL.
// However, these are the EASTL unit tests and we can say that they are also owned by EASTL.
namespace eastl
{
	template <> 
	struct hash<TestObject>
	{
		size_t operator()(const TestObject& a) const 
			{ return static_cast<size_t>(a.mX); }
	};
}


// use_mX
// Used for printing TestObject contents via the PrintSequence function,
// which is defined below. See the PrintSequence function for documentation.
// This function is an analog of the eastl::use_self and use_first functions.
// We declare this all in one line because the user should never need to 
// debug usage of this function.
template <typename T> struct use_mX { int operator()(const T& t) const { return t.mX; } };



///////////////////////////////////////////////////////////////////////////////
// SizedPOD
//
// Exists for the purpose testing PODs that are larger than built-in types.
//
template <size_t kSize>
struct SizedPOD
{
	char memory[kSize];
};



///////////////////////////////////////////////////////////////////////////////
/// ConstType
///
/// Used to test const type containers (e.g. vector<const ConstType>).
///
class ConstType
{
public:
	ConstType(int value) : mDummy(value) {};
	int mDummy;
};




///////////////////////////////////////////////////////////////////////////////
/// TestObjectHash
///
/// Implements a manually specified hash function for TestObjects.
///
struct TestObjectHash
{
	size_t operator()(const TestObject& t) const 
	{
		return (size_t)t.mX;
	}
};





///////////////////////////////////////////////////////////////////////////////
/// Align16
///

#if defined(EA_PROCESSOR_ARM)
	#define kEASTLTestAlign16 8 //ARM processors can only align to 8 
#else
	#define kEASTLTestAlign16 16
#endif


EA_PREFIX_ALIGN(kEASTLTestAlign16)
struct Align16
{
	explicit Align16(int x = 0) : mX(x) {}
	int mX;
} EA_POSTFIX_ALIGN(kEASTLTestAlign16);

inline bool operator==(const Align16& a, const Align16& b)
	{ return (a.mX == b.mX); }

inline bool operator<(const Align16& a, const Align16& b)
	{ return (a.mX < b.mX); }



///////////////////////////////////////////////////////////////////////////////
/// Align32
///
#if defined(EA_PROCESSOR_ARM)
	#define kEASTLTestAlign32 8 //ARM processors can only align to 8 
#elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) < 400) // GCC 2.x, 3.x
	#define kEASTLTestAlign32 16 // Some versions of GCC fail to support any alignment beyond 16.
#else
	#define kEASTLTestAlign32 32
#endif

EA_PREFIX_ALIGN(kEASTLTestAlign32)
struct Align32
{
	explicit Align32(int x = 0) : mX(x) {}
	int mX;
} EA_POSTFIX_ALIGN(kEASTLTestAlign32);

inline bool operator==(const Align32& a, const Align32& b)
	{ return (a.mX == b.mX); }

inline bool operator<(const Align32& a, const Align32& b)
	{ return (a.mX < b.mX); }



///////////////////////////////////////////////////////////////////////////////
/// Align64
///
/// Used for testing of alignment.
///
#if defined(EA_PROCESSOR_ARM)
	#define kEASTLTestAlign64 8
#elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) < 400) // GCC 2.x, 3.x
	#define kEASTLTestAlign64 16 // Some versions of GCC fail to support any alignment beyond 16.
#else
	#define kEASTLTestAlign64 64
#endif

EA_PREFIX_ALIGN(kEASTLTestAlign64)
struct Align64
{
	explicit Align64(int x = 0) : mX(x) {}
	int mX;
} EA_POSTFIX_ALIGN(kEASTLTestAlign64);

inline bool operator==(const Align64& a, const Align64& b)
	{ return (a.mX == b.mX); }

inline bool operator<(const Align64& a, const Align64& b)
	{ return (a.mX < b.mX); }

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





/// test_use_self
///
/// Intentionally avoiding a dependency on eastl::use_self.
///
template <typename T>
struct test_use_self
{
	const T& operator()(const T& x) const
		{ return x; }
};



/// GenerateIncrementalIntegers
///
/// Used to seed containers with incremental values based on integers.
///
/// Example usage:
///     vector<int> v(10, 0);
///     generate(v.begin(), v.end(), GenerateIncrementalIntegers<int>());
///     // v will now have 0, 1, 2, ... 8, 9.
/// 
///     generate_n(intArray.begin(), 10, GenerateIncrementalIntegers<int>());
///     // v will now have 0, 1, 2, ... 8, 9.
///
///     vector<TestObject> vTO(10, 0);
///     generate(vTO.begin(), vTO.end(), GenerateIncrementalIntegers<TestObject>());
///     // vTO will now have 0, 1, 2, ... 8, 9.
/// 
template <typename T>
struct GenerateIncrementalIntegers
{
	int mX;

	GenerateIncrementalIntegers(int x = 0)
		: mX(x) { }

	void reset(int x = 0)
		{ mX = x; }

	T operator()()
		{ return T(mX++); } 
};



/// SetIncrementalIntegers
///
/// Used to seed containers with incremental values based on integers.
///
/// Example usage:
///     vector<int> v(10, 0);
///     for_each(v.begin(), v.end(), SetIncrementalIntegers<int>());
///     // v will now have 0, 1, 2, ... 8, 9.
/// 
template <typename T>
struct SetIncrementalIntegers
{
	int mX;

	SetIncrementalIntegers(int x = 0)
		: mX(x) { }

	void reset(int x = 0)
		{ mX = x; }

	void operator()(T& t)
		{ t = T(mX++); } 
};



/// CompareContainers
///
/// Does a comparison between the contents of two containers. 
///
/// Specifically tests for the following properties:
///     empty() is the same for both
///     size() is the same for both
///     iteration through both element by element yields equal values.
///
template <typename T1, typename T2, typename ExtractValue1, typename ExtractValue2>
int CompareContainers(const T1& t1, const T2& t2, const char* ppName, 
					  ExtractValue1 ev1 = test_use_self<T1>(), ExtractValue2 ev2 = test_use_self<T2>())
{
	int nErrorCount = 0;

	// Compare emptiness.
	VERIFY(t1.empty() == t2.empty());

	// Compare sizes.
	const size_t nSize1 = t1.size();
	const size_t nSize2 = t2.size();

	VERIFY(nSize1 == nSize2);
	if(nSize1 != nSize2)
		EASTLTest_Printf("%s: Container size difference: %u, %u\n", ppName, (unsigned)nSize1, (unsigned)nSize2);

	// Compare values.
	if(nSize1 == nSize2)
	{
		// Test iteration
		typename T1::const_iterator it1 = t1.begin();
		typename T2::const_iterator it2 = t2.begin();

		for(unsigned j = 0; it1 != t1.end(); ++it1, ++it2, ++j)
		{
			const typename T1::value_type& v1 = *it1;
			const typename T2::value_type& v2 = *it2;

			VERIFY(ev1(v1) == ev2(v2));
			if(!(ev1(v1) == ev2(v2)))
			{
				EASTLTest_Printf("%s: Container iterator difference at index %d\n", ppName, j);
				break;  
			}
		}

		VERIFY(it1 == t1.end());
		VERIFY(it2 == t2.end());
	}

	return nErrorCount;
}





/// VerifySequence
///
/// Allows the user to specify that a container has a given set of values.
/// 
/// Example usage:
///    vector<int> v;
///    v.push_back(1); v.push_back(3); v.push_back(5);
///    VerifySequence(v.begin(), v.end(), int(), "v.push_back", 1, 3, 5, -1);
///
/// Note: The StackValue template argument is a hint to the compiler about what type 
///       the passed vararg sequence is.
///
template <typename InputIterator, typename StackValue>
bool VerifySequence(InputIterator first, InputIterator last, StackValue /*unused*/, const char* pName, ...)
{
	typedef typename eastl::iterator_traits<InputIterator>::value_type value_type;

	int        argIndex = 0;
	int        seqIndex = 0;
	bool       bReturnValue = true;
	StackValue next;

	va_list args;
	va_start(args, pName);

	for( ; first != last; ++first, ++argIndex, ++seqIndex)
	{
		next = va_arg(args, StackValue);

		if((next == StackValue(-1)) || !(value_type(next) == *first))
		{
			if(pName)
				EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, argIndex);
			else
				EASTLTest_Printf("Mismatch at index %d\n", argIndex);
			bReturnValue = false;
		}
	}

	for(; first != last; ++first)
		++seqIndex;

	if(bReturnValue)
	{
		next = va_arg(args, StackValue);

		if(!(next == StackValue(-1)))
		{
			do {
				++argIndex;
				next = va_arg(args, StackValue);
			} while(!(next == StackValue(-1)));

			if(pName)
				EASTLTest_Printf("[%s] Too many elements: expected %d, found %d\n", pName, argIndex, seqIndex);
			else
				EASTLTest_Printf("Too many elements: expected %d, found %d\n", argIndex, seqIndex);
			bReturnValue = false;
		}
	}

	va_end(args);

	return bReturnValue;
}




/// PrintSequence
///
/// Allows the user to print a sequence of values.
/// 
/// Example usage:
///    vector<int> v;
///    PrintSequence(v.begin(), v.end(), use_self<int>(), 100, "vector", 1, 3, 5, -1);
///
/// Example usage:
///    template <typename T> struct use_mX { int operator()(const T& t) const { return t.mX; } };
///    vector<TestObject> v;
///    PrintSequence(v.begin(), v.end(), use_mX<TestObject>(), 100, "vector", 1, 3, 5, -1);
///    
template <typename InputIterator, typename ExtractInt>
void PrintSequence(InputIterator first, InputIterator last, ExtractInt extractInt, int nMaxCount, const char* pName, ...)
{
	if(pName)
		EASTLTest_Printf("[%s]", pName);

	for(int i = 0; (i < nMaxCount) && (first != last); ++i, ++first)
	{
		EASTLTest_Printf("%d ", (int)extractInt(*first));
	}

	EASTLTest_Printf("\n");
}




/// demoted_iterator
///
/// Converts an iterator into a demoted category. For example, you can convert
/// an iterator of type bidirectional_iterator_tag to forward_iterator_tag.
/// The following is a list of iterator types. A demonted iterator can be demoted
/// only to a lower iterator category (earlier in the following list):
///     input_iterator_tag
///     forward_iterator_tag
///     bidirectional_iterator_tag
///     random_access_iterator_tag
///     contiguous_iterator_tag
///
/// Converts something which can be iterated into a formal input iterator.
/// This class is useful for testing functions and algorithms that expect
/// InputIterators, which are the lowest and 'weakest' form of iterators.
/// 
/// Key traits of InputIterators:
///    Algorithms on input iterators should never attempt to pass
///    through the same iterator twice. They should be single pass 
///    algorithms. value_type T is not required to be an lvalue type.
///
/// Example usage:
///     typedef demoted_iterator<int*, eastl::bidirectional_iterator_tag>         PointerAsBidirectionalIterator;
///     typedef demoted_iterator<MyVector::iterator, eastl::forward_iterator_tag> VectorIteratorAsForwardIterator;
///
/// Example usage:
///     IntVector v;
///     comb_sort(to_forward_iterator(v.begin()), to_forward_iterator(v.end()));
///
template <typename Iterator, typename IteratorCategory>
class demoted_iterator
{
protected:
	Iterator mIterator;

public:
	typedef demoted_iterator<Iterator, IteratorCategory>                 this_type;
	typedef Iterator                                                     iterator_type;
	typedef IteratorCategory                                             iterator_category;
	typedef typename eastl::iterator_traits<Iterator>::value_type        value_type;
	typedef typename eastl::iterator_traits<Iterator>::difference_type   difference_type;
	typedef typename eastl::iterator_traits<Iterator>::reference         reference;
	typedef typename eastl::iterator_traits<Iterator>::pointer           pointer;

	demoted_iterator()
		: mIterator() { }

	explicit demoted_iterator(const Iterator& i)
		: mIterator(i) { }

	demoted_iterator(const this_type& x)
		: mIterator(x.mIterator) { }

	this_type& operator=(const Iterator& i)
		{ mIterator = i; return *this; }

	this_type& operator=(const this_type& x)
		{ mIterator = x.mIterator; return *this; }

	reference operator*() const
		{ return *mIterator; }

	pointer operator->() const
		{ return mIterator; }

	this_type& operator++()
		{ ++mIterator; return *this; }

	this_type operator++(int)
		{ return this_type(mIterator++); }

	this_type& operator--()
		{ --mIterator; return *this; }

	this_type operator--(int)
		{ return this_type(mIterator--); }

	reference operator[](const difference_type& n) const
		{ return mIterator[n]; }

	this_type& operator+=(const difference_type& n)
		{ mIterator += n; return *this; }

	this_type operator+(const difference_type& n) const
		{ return this_type(mIterator + n); }

	this_type& operator-=(const difference_type& n)
		{ mIterator -= n; return *this; }

	this_type operator-(const difference_type& n) const
		{ return this_type(mIterator - n); }

	const iterator_type& base() const
		{ return mIterator; }

}; // class demoted_iterator

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator==(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return a.base() == b.base(); }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator!=(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return !(a == b); }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator<(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return a.base() < b.base(); }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator<=(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return !(b < a); }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator>(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return b < a; }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline bool
operator>=(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return !(a < b); }

template<typename Iterator1, typename IteratorCategory1, typename Iterator2, typename IteratorCategory2>
inline demoted_iterator<Iterator1, IteratorCategory1>
operator-(const demoted_iterator<Iterator1, IteratorCategory1>& a, const demoted_iterator<Iterator2, IteratorCategory2>& b)
	{ return demoted_iterator<Iterator1, IteratorCategory1>(a.base() - b.base()); }

template<typename Iterator1, typename IteratorCategory1>
inline demoted_iterator<Iterator1, IteratorCategory1>
operator+(typename demoted_iterator<Iterator1, IteratorCategory1>::difference_type n, const demoted_iterator<Iterator1, IteratorCategory1>& a)
	{ return a + n; }


// to_xxx_iterator
//
// Returns a demoted iterator
//
template <typename Iterator>
inline demoted_iterator<Iterator, EASTL_ITC_NS::input_iterator_tag>
to_input_iterator(const Iterator& i)
	{ return demoted_iterator<Iterator, EASTL_ITC_NS::input_iterator_tag>(i); }

template <typename Iterator>
inline demoted_iterator<Iterator, EASTL_ITC_NS::forward_iterator_tag>
to_forward_iterator(const Iterator& i)
	{ return demoted_iterator<Iterator, EASTL_ITC_NS::forward_iterator_tag>(i); }

template <typename Iterator>
inline demoted_iterator<Iterator, EASTL_ITC_NS::bidirectional_iterator_tag>
to_bidirectional_iterator(const Iterator& i)
	{ return demoted_iterator<Iterator, EASTL_ITC_NS::bidirectional_iterator_tag>(i); }

template <typename Iterator>
inline demoted_iterator<Iterator, EASTL_ITC_NS::random_access_iterator_tag>
to_random_access_iterator(const Iterator& i)
	{ return demoted_iterator<Iterator, EASTL_ITC_NS::random_access_iterator_tag>(i); }






///////////////////////////////////////////////////////////////////////////////
// MallocAllocator
//
// Implements an EASTL allocator that uses malloc/free as opposed to 
// new/delete or PPMalloc Malloc/Free. This is useful for testing 
// allocator behaviour of code.
//
// Example usage:
//      vector<int, MallocAllocator> intVector;
//
class MallocAllocator
{
public:
	MallocAllocator(const char* = EASTL_NAME_VAL("MallocAllocator"))
		: mAllocCount(0), mFreeCount(0), mAllocVolume(0) {}

	MallocAllocator(const MallocAllocator& x)
		: mAllocCount(x.mAllocCount), mFreeCount(x.mFreeCount), mAllocVolume(x.mAllocVolume) {}

	MallocAllocator(const MallocAllocator& x, const char*) : MallocAllocator(x) {}

	MallocAllocator& operator=(const MallocAllocator& x)
	{
		mAllocCount = x.mAllocCount;
		mFreeCount = x.mFreeCount;
		mAllocVolume = x.mAllocVolume;
		return *this;
	}

	void* allocate(size_t n, int = 0);
	void* allocate(size_t n, size_t, size_t, int = 0); // We don't support alignment, so you can't use this class where alignment is required.
	void deallocate(void* p, size_t n);

	const char* get_name() const { return "MallocAllocator"; }
	void set_name(const char*) {}

	static void reset_all()
	{
		mAllocCountAll = 0;
		mFreeCountAll = 0;
		mAllocVolumeAll = 0;
		mpLastAllocation = NULL;
	}

public:
	int mAllocCount;
	int mFreeCount;
	size_t mAllocVolume;

	static int mAllocCountAll;
	static int mFreeCountAll;
	static size_t mAllocVolumeAll;
	static void* mpLastAllocation;
};

inline bool operator==(const MallocAllocator&, const MallocAllocator&) { return true; }
inline bool operator!=(const MallocAllocator&, const MallocAllocator&) { return false; }


///////////////////////////////////////////////////////////////////////////////
// CustomAllocator
//
// Implements an allocator that works just like eastl::allocator but is defined
// within this test as opposed to within EASTL.
//
// Example usage:
//      vector<int, CustomAllocator> intVector;
//
class CustomAllocator
{
public:
	CustomAllocator(const char* = NULL) {}
	CustomAllocator(const CustomAllocator&) {}
	CustomAllocator(const CustomAllocator&, const char*) {}
	CustomAllocator& operator=(const CustomAllocator&) { return *this; }

	void* allocate(size_t n, int flags = 0);
	void* allocate(size_t n, size_t, size_t, int flags = 0);
	void deallocate(void* p, size_t n);

	const char* get_name() const { return "CustomAllocator"; }
	void set_name(const char*) {}
};

inline bool operator==(const CustomAllocator&, const CustomAllocator&) { return true; }
inline bool operator!=(const CustomAllocator&, const CustomAllocator&) { return false; }


///////////////////////////////////////////////////////////////////////////////
/// UnequalAllocator
///
/// Acts the same as eastl::allocator, but always compares as unequal to an 
/// instance of itself.
///
class UnequalAllocator
{
public:
	EASTL_ALLOCATOR_EXPLICIT UnequalAllocator(const char* pName = EASTL_NAME_VAL(EASTL_ALLOCATOR_DEFAULT_NAME))
	    : mAllocator(pName) {}

	UnequalAllocator(const UnequalAllocator& x) : mAllocator(x.mAllocator) {}
	UnequalAllocator(const UnequalAllocator& x, const char* pName) : mAllocator(x.mAllocator) { set_name(pName); }
	UnequalAllocator& operator=(const UnequalAllocator& x)
	{
		mAllocator = x.mAllocator;
		return *this;
	}

	void* allocate(size_t n, int flags = 0) { return mAllocator.allocate(n, flags); }
	void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0) { return mAllocator.allocate(n, alignment, offset, flags); }
	void deallocate(void* p, size_t n) { return mAllocator.deallocate(p, n); }

	const char* get_name() const { return mAllocator.get_name(); }
	void set_name(const char* pName) { mAllocator.set_name(pName); }

protected:
	eastl::allocator mAllocator;
};

inline bool operator==(const UnequalAllocator&, const UnequalAllocator&) { return false; }
inline bool operator!=(const UnequalAllocator&, const UnequalAllocator&) { return true; }


///////////////////////////////////////////////////////////////////////////////
/// CountingAllocator
///
/// Counts allocation events allowing unit tests to validate assumptions.
///
class CountingAllocator : public eastl::allocator
{
public:
	using base_type = eastl::allocator;

	EASTL_ALLOCATOR_EXPLICIT CountingAllocator(const char* pName = EASTL_NAME_VAL(EASTL_ALLOCATOR_DEFAULT_NAME))
	    : base_type(pName)
	{
		totalCtorCount++;
		defaultCtorCount++;
	}

	CountingAllocator(const CountingAllocator& x) : base_type(x)
	{
		totalCtorCount++;
		copyCtorCount++;
	}

	CountingAllocator(const CountingAllocator& x, const char* pName) : base_type(x)
	{
		totalCtorCount++;
		copyCtorCount++;
		set_name(pName);
	}

	CountingAllocator& operator=(const CountingAllocator& x)
	{
		base_type::operator=(x);
		assignOpCount++;
		return *this;
	}

	virtual void* allocate(size_t n, int flags = 0)
	{
		activeAllocCount++;
		totalAllocCount++;
		totalAllocatedMemory += n;
		activeAllocatedMemory += n;
		return base_type::allocate(n, flags);
	}

	virtual void* allocate(size_t n, size_t alignment, size_t offset, int flags = 0)
	{
		activeAllocCount++;
		totalAllocCount++;
		totalAllocatedMemory += n;
		activeAllocatedMemory += n;
		return base_type::allocate(n, alignment, offset, flags);
	}

	void deallocate(void* p, size_t n)
	{
		activeAllocCount--;
		totalDeallocCount--;
		activeAllocatedMemory -= n;
		return base_type::deallocate(p, n);
	}

	const char* get_name() const          { return base_type::get_name(); }
	void set_name(const char* pName)      { base_type::set_name(pName); }

	static auto getTotalAllocationCount()  { return totalAllocCount; }
	static auto getTotalAllocationSize()   { return totalAllocatedMemory; }
	static auto getActiveAllocationSize()  { return activeAllocatedMemory; }
	static auto getActiveAllocationCount() { return activeAllocCount; }
	static auto neverUsed()				   { return totalAllocCount == 0; }

	static void resetCount()
	{
		activeAllocCount      = 0;
		totalAllocCount       = 0;
		totalDeallocCount     = 0;
		totalCtorCount        = 0;
		defaultCtorCount      = 0;
		copyCtorCount         = 0;
		assignOpCount         = 0;
		totalAllocatedMemory  = 0;
		activeAllocatedMemory = 0;
	}

	static uint64_t activeAllocCount;
	static uint64_t totalAllocCount;
	static uint64_t totalDeallocCount;
	static uint64_t totalCtorCount;
	static uint64_t defaultCtorCount;
	static uint64_t copyCtorCount;
	static uint64_t assignOpCount;
	static uint64_t totalAllocatedMemory;  // the total amount of memory allocated
	static uint64_t activeAllocatedMemory; // currently allocated memory by allocator
};

inline bool operator==(const CountingAllocator& rhs, const CountingAllocator& lhs) { return operator==(CountingAllocator::base_type(rhs), CountingAllocator::base_type(lhs)); }
inline bool operator!=(const CountingAllocator& rhs, const CountingAllocator& lhs) { return !(rhs == lhs); }




///////////////////////////////////////////////////////////////////////////////
// InstanceAllocator
//
// Implements an allocator which has a instance id that makes it different
// from other InstanceAllocators of a different id. Allocations between 
// InstanceAllocators of different ids are incompatible. An allocation done 
// by an InstanceAllocator of id=0 cannot be freed by an InstanceAllocator
// of id=1.
//
// Example usage:
//         InstanceAllocator ia0((uint8_t)0);
//         InstanceAllocator ia1((uint8_t)1);
// 
//         eastl::list<int, InstanceAllocator> list0(1, ia0);
//         eastl::list<int, InstanceAllocator> list1(1, ia1);
// 
//         list0 = list1; // list0 cannot free it's current contents with list1's allocator, and InstanceAllocator's purpose is to detect if it mistakenly does so.
//
class InstanceAllocator
{
public:
	enum
	{
		kMultiplier = 16
	}; // Use 16 because it's the highest currently known platform alignment requirement.

	InstanceAllocator(const char* = NULL, uint8_t instanceId = 0) : mInstanceId(instanceId) {}
	InstanceAllocator(uint8_t instanceId) : mInstanceId(instanceId) {}
	InstanceAllocator(const InstanceAllocator& x) : mInstanceId(x.mInstanceId) {}
	InstanceAllocator(const InstanceAllocator& x, const char*) : mInstanceId(x.mInstanceId) {}

	InstanceAllocator& operator=(const InstanceAllocator& x)
	{
		mInstanceId = x.mInstanceId;
		return *this;
	}

	void* allocate(size_t n, int = 0)
	{ // +1 so that we always have space to write mInstanceId.
		uint8_t* p8 =
		    static_cast<uint8_t*>(malloc(n + (kMultiplier * (mInstanceId + 1)))); // We make allocations between
		                                                                          // different instances incompatible by
		                                                                          // tweaking their return values.
		eastl::fill(p8, p8 + kMultiplier, 0xff);
		EA_ANALYSIS_ASSUME(p8 != NULL);
		*p8 = mInstanceId;
		return p8 + (kMultiplier * (mInstanceId + 1));
	}

	void* allocate(size_t n, size_t, size_t, int = 0)
	{ // +1 so that we always have space to write mInstanceId.
		uint8_t* p8 =
		    static_cast<uint8_t*>(malloc(n + (kMultiplier * (mInstanceId + 1)))); // We make allocations between
		                                                                          // different instances incompatible by
		                                                                          // tweaking their return values.
		eastl::fill(p8, p8 + kMultiplier, 0xff);
		EA_ANALYSIS_ASSUME(p8 != NULL);
		*p8 = mInstanceId;
		return p8 + (kMultiplier * (mInstanceId + 1));
	}

	void deallocate(void* p, size_t /*n*/)
	{
		uint8_t* p8 = static_cast<uint8_t*>(p) - (kMultiplier * (mInstanceId + 1));
		EASTL_ASSERT(*p8 == mInstanceId); // mInstanceId must match the id used in allocate(), otherwise the behavior is
		                                  // undefined (probably a heap assert).
		if (*p8 == mInstanceId) // It's possible that *p8 coincidentally matches mInstanceId if p8 is offset into memory
		                        // we don't control.
			free(p8);
		else
			++mMismatchCount;
	}

	const char* get_name()
	{
		sprintf(mName, "InstanceAllocator %u", mInstanceId);
		return mName;
	}

	void set_name(const char*) {}

	static void reset_all() { mMismatchCount = 0; }

public:
	uint8_t mInstanceId;
	char mName[32];

	static int mMismatchCount;
};

inline bool operator==(const InstanceAllocator& a, const InstanceAllocator& b) { return (a.mInstanceId == b.mInstanceId); }
inline bool operator!=(const InstanceAllocator& a, const InstanceAllocator& b) { return (a.mInstanceId != b.mInstanceId); }


///////////////////////////////////////////////////////////////////////////////
// ThrowingAllocator
//
// Implements an EASTL allocator that uses malloc/free as opposed to 
// new/delete or PPMalloc Malloc/Free. This is useful for testing 
// allocator behaviour of code.
//
// Example usage:
//      vector<int, ThrowingAllocator< false<> > intVector;
//
template <bool initialShouldThrow = true>
class ThrowingAllocator
{
public:
	ThrowingAllocator(const char* = EASTL_NAME_VAL("ThrowingAllocator")) : mbShouldThrow(initialShouldThrow) {}
	ThrowingAllocator(const ThrowingAllocator& x) : mbShouldThrow(x.mbShouldThrow) {}
	ThrowingAllocator(const ThrowingAllocator& x, const char*) : mbShouldThrow(x.mbShouldThrow) {}

	ThrowingAllocator& operator=(const ThrowingAllocator& x)
	{
		mbShouldThrow = x.mbShouldThrow;
		return *this;
	}

	void* allocate(size_t n, int = 0)
	{
#if EASTL_EXCEPTIONS_ENABLED
		if (mbShouldThrow)
			throw std::bad_alloc();
#endif
		return malloc(n);
	}

	void* allocate(size_t n, size_t, size_t, int = 0)
	{
#if EASTL_EXCEPTIONS_ENABLED
		if (mbShouldThrow)
			throw std::bad_alloc();
#endif
		return malloc(n); // We don't support alignment, so you can't use this class where alignment is required.
	}

	void deallocate(void* p, size_t) { free(p); }

	const char* get_name() const { return "ThrowingAllocator"; }
	void set_name(const char*) {}

	void set_should_throw(bool shouldThrow) { mbShouldThrow = shouldThrow; }
	bool get_should_throw() const { return mbShouldThrow; }

protected:
	bool mbShouldThrow;
};

template <bool initialShouldThrow>
inline bool operator==(const ThrowingAllocator<initialShouldThrow>&, const ThrowingAllocator<initialShouldThrow>&)
{
	return true;
}

template <bool initialShouldThrow>
inline bool operator!=(const ThrowingAllocator<initialShouldThrow>&, const ThrowingAllocator<initialShouldThrow>&)
{
	return false;
}


///////////////////////////////////////////////////////////////////////////////
// Helper utility that does a case insensitive string comparsion with two sets of overloads
//
struct TestStrCmpI_2
{
	bool operator()(const char* pCStr, const eastl::string& str) const { return str.comparei(pCStr) == 0; }
	bool operator()(const eastl::string& str, const char* pCStr) const { return str.comparei(pCStr) == 0; }
};


///////////////////////////////////////////////////////////////////////////////
// StompDetectAllocator
// 
// An allocator that has sentinal values surrounding its allocator in an 
// effort to detected if its internal memory has been stomped.
//
static uint64_t STOMP_MAGIC_V1 = 0x0101DEC1A551F1ED;
static uint64_t STOMP_MAGIC_V2 = 0x12345C1A551F1ED5;

struct StompDetectAllocator
{
	StompDetectAllocator() { Validate(); }
	~StompDetectAllocator() { Validate(); }

	StompDetectAllocator(const char*) { Validate(); }

	void* allocate(size_t n, int = 0) { return mMallocAllocator.allocate(n); }
	void* allocate(size_t n, size_t, size_t, int = 0) { return mMallocAllocator.allocate(n); }
	void deallocate(void* p, size_t n) { mMallocAllocator.deallocate(p, n); }

	const char* get_name() const { return "FatAllocator"; }
	void set_name(const char*) {}

	void Validate() const
	{
		EASTL_ASSERT(mSentinal1 == STOMP_MAGIC_V1);
		EASTL_ASSERT(mSentinal2 == STOMP_MAGIC_V2);
	}

	uint64_t mSentinal1 = STOMP_MAGIC_V1;
	MallocAllocator mMallocAllocator;
	uint64_t mSentinal2 = STOMP_MAGIC_V2;
};

inline bool operator==(const StompDetectAllocator& a, const StompDetectAllocator& b)
{
	a.Validate();
	b.Validate();

	return (a.mMallocAllocator == b.mMallocAllocator);
}

inline bool operator!=(const StompDetectAllocator& a, const StompDetectAllocator& b)
{
	a.Validate();
	b.Validate();

	return (a.mMallocAllocator != b.mMallocAllocator);
}


// Commonly used free-standing functions to test callables
inline int ReturnVal(int param) { return param; }
inline int ReturnZero() { return 0; }
inline int ReturnOne() { return 1; }


// ValueInit
template<class T>
struct ValueInitOf
{
	ValueInitOf() : mV() {}
	~ValueInitOf() = default;

	ValueInitOf(const ValueInitOf&) = default;
	ValueInitOf(ValueInitOf&&) = default;

	ValueInitOf& operator=(const ValueInitOf&) = default;
	ValueInitOf& operator=(ValueInitOf&&) = default;

	T get() { return mV; }

	T mV;
};

// MoveOnlyType - useful for verifying containers that may hold, e.g., unique_ptrs to make sure move ops are implemented
struct MoveOnlyType
{
	MoveOnlyType() = delete;
	MoveOnlyType(int val) : mVal(val) {}
	MoveOnlyType(const MoveOnlyType&) = delete;
	MoveOnlyType(MoveOnlyType&& x) : mVal(x.mVal) { x.mVal = 0; }
	MoveOnlyType& operator=(const MoveOnlyType&) = delete;
	MoveOnlyType& operator=(MoveOnlyType&& x)
	{
		mVal = x.mVal;
		x.mVal = 0;
		return *this;
	}
	bool operator==(const MoveOnlyType& o) const { return mVal == o.mVal; }

	int mVal;
};

// MoveOnlyTypeDefaultCtor - useful for verifying containers that may hold, e.g., unique_ptrs to make sure move ops are implemented
struct MoveOnlyTypeDefaultCtor
{
	MoveOnlyTypeDefaultCtor() = default;
	MoveOnlyTypeDefaultCtor(int val) : mVal(val) {}
	MoveOnlyTypeDefaultCtor(const MoveOnlyTypeDefaultCtor&) = delete;
	MoveOnlyTypeDefaultCtor(MoveOnlyTypeDefaultCtor&& x) : mVal(x.mVal) { x.mVal = 0; }
	MoveOnlyTypeDefaultCtor& operator=(const MoveOnlyTypeDefaultCtor&) = delete;
	MoveOnlyTypeDefaultCtor& operator=(MoveOnlyTypeDefaultCtor&& x)
	{
		mVal = x.mVal;
		x.mVal = 0;
		return *this;
	}
	bool operator==(const MoveOnlyTypeDefaultCtor& o) const { return mVal == o.mVal; }

	int mVal;
};



//////////////////////////////////////////////////////////////////////////////
// Utility RAII class that sets a new default allocator for the scope
//
struct AutoDefaultAllocator
{
	eastl::allocator* mPrevAllocator = nullptr;

	AutoDefaultAllocator(eastl::allocator* nextAllocator) { mPrevAllocator = SetDefaultAllocator(nextAllocator); }
	~AutoDefaultAllocator()                               { SetDefaultAllocator(mPrevAllocator); }
};


#endif // Header include guard