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

// todo:
// Test Encoding
// Test StringHash
// Test exceptions

#if EASTL_OPENSOURCE
	#define EASTL_SNPRINTF_TESTS_ENABLED 0
#else
	#define EASTL_SNPRINTF_TESTS_ENABLED 1
#endif


template<typename StringType>
int TEST_STRING_NAME()
{
	int nErrorCount = 0;

	struct Failocator
	{
		Failocator() = default;
		Failocator(const char*) {}

		void* allocate(size_t) { EA_FAIL(); return nullptr; }
		void deallocate(void*, size_t) { EA_FAIL(); }
	};

	#if defined(EA_PLATFORM_ANDROID)
		EA_DISABLE_CLANG_WARNING(-Wunknown-warning-option)  // warning: disable unknown warning suppression pragmas
		EA_DISABLE_CLANG_WARNING(-Wunknown-pragmas)         // warning: disable unknown warning suppression pragmas
		EA_DISABLE_CLANG_WARNING(-Winherited-variadic-ctor) // warning: inheriting constructor does not inherit ellipsis
	#endif

	struct SSOStringType : public StringType
	{
		using StringType::StringType;
		using StringType::IsSSO;
	};

	// Use custom string type that always fails to allocate memory to highlight when SSO is not functioning correctly.
	struct SSOFailocatorString : public eastl::basic_string<typename StringType::value_type, Failocator>
	{
		using eastl::basic_string<typename StringType::value_type, Failocator>::basic_string;
		using eastl::basic_string<typename StringType::value_type, Failocator>::IsSSO;
	};

	#if defined(EA_PLATFORM_ANDROID)
		EA_RESTORE_CLANG_WARNING()
		EA_RESTORE_CLANG_WARNING()
		EA_RESTORE_CLANG_WARNING()
	#endif

	// SSO (short string optimization) tests
	{
		{
			SSOFailocatorString str;
			VERIFY(str.validate());
			VERIFY(str.empty());
			VERIFY(str.IsSSO());
		}

		EA_CONSTEXPR_IF(EA_PLATFORM_WORD_SIZE == 8 && EASTL_SIZE_T_32BIT == 0)
		{
			// test SSO size on 64 bit platforms
			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 1)
			{
				// we can fit 23 characters on 64bit system with 1 byte chars
				const auto* pLiteral = LITERAL("aaaaaaaaaaaaaaaaaaaaaaa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 23);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}

			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 2)
			{
				// we can fit 11 characters on 64 bit system with 2 byte chars
				const auto* pLiteral = LITERAL("aaaaaaaaaaa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 11);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}

			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 4)
			{
				// we can fit 5 characters on 64 bit system with 4 byte chars
				const auto* pLiteral = LITERAL("aaaaa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 5);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}
		}

		EA_CONSTEXPR_IF(EA_PLATFORM_WORD_SIZE == 4)
		{
			// test SSO size on 32 bit platforms
			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 1)
			{
				// we can fit 11 characters on 32bit system with 1 byte chars
				const auto* pLiteral = LITERAL("aaaaaaaaaaa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 11);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}

			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 2)
			{
				// we can fit 5 characters on 32 bit system with 2 byte chars
				const auto* pLiteral = LITERAL("aaaaa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 5);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}

			EA_CONSTEXPR_IF(sizeof(typename StringType::value_type) == 4)
			{
				// we can fit 2 characters on 32 bit system with 4 byte chars
				const auto* pLiteral = LITERAL("aa");
				SSOFailocatorString str(pLiteral);

				VERIFY(EA::StdC::Strlen(pLiteral) == 2);
				VERIFY(str == pLiteral);
				VERIFY(str.validate());
				VERIFY(str.IsSSO());
			}
		}
	}

	// basic_string();
	{
		StringType str;
		VERIFY(str.empty());
		VERIFY(str.length() == 0);
		VERIFY(str.validate());
	}

	// explicit basic_string(const allocator_type& allocator);
	{
		typename StringType::allocator_type alloc;
		StringType str(alloc);
		VERIFY(str.validate());
	}

	// basic_string(const value_type* p, size_type n, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"), 26);
			VERIFY(str[5] == LITERAL('f'));
			VERIFY(!str.empty());
			VERIFY(str.length() == 26);
			VERIFY(str.validate());
		}

		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			VERIFY(str[5] == LITERAL('f'));
			VERIFY(!str.empty());
			VERIFY(str.length() == 26);
			VERIFY(str.validate());
		}
	}

	// basic_string(const this_type& x, size_type position, size_type n = npos);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		StringType str2(str1, 3, 3);
		VERIFY(str2 == LITERAL("def"));
		VERIFY(str2.size() == 3);
		VERIFY(str2.length() == 3);
		VERIFY(str2.capacity() >= 3);  // SSO buffer size

		StringType str3(str1, 25, 3);
		VERIFY(str3 == LITERAL("z"));
		VERIFY(str3.size() == 1);
		VERIFY(str3.length() == 1);
		VERIFY(str3.capacity() >= 1); // SSO buffer size

		VERIFY(str1.validate());
		VERIFY(str2.validate());
		VERIFY(str3.validate());
	}

	// EASTL_STRING_EXPLICIT basic_string(const value_type* p, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		auto* pLiteral = LITERAL("abcdefghijklmnopqrstuvwxyz");
		StringType str(pLiteral);
		VERIFY(str == pLiteral);
	}

	// basic_string(size_type n, value_type c, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		StringType str(32, LITERAL('a'));
		VERIFY(!str.empty());
		VERIFY(str.size() == 32);
		VERIFY(str.length() == 32);
		VERIFY(str == LITERAL("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));

		VERIFY(str.validate());
	}

	// basic_string(const this_type& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2(str1);

		VERIFY(str1 == str2);
		VERIFY(str1.size() == str2.size());
		VERIFY(str1.empty() == str2.empty());
		VERIFY(str1.length() == str2.length());
		VERIFY(EA::StdC::Memcmp(str1.data(), str2.data(), str1.size()) == 0);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// basic_string(const value_type* pBegin, const value_type* pEnd, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto* pStart = str1.data() + 5;
		auto* pEnd = str1.data() + 20;

		StringType str(pStart, pEnd);
		VERIFY(str == LITERAL("fghijklmnopqrst"));
		VERIFY(!str.empty());
		VERIFY(str.size() == 15);
	}

	// basic_string(CtorDoNotInitialize, size_type n, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		StringType str(typename StringType::CtorDoNotInitialize(), 42);
		VERIFY(str.size() == 0);
		VERIFY(str.length() == 0);
		VERIFY(str.capacity() == 42);
	}

	// basic_string(CtorSprintf, const value_type* pFormat, ...);
	{
	#if EASTL_SNPRINTF_TESTS_ENABLED
		{
			StringType str(typename StringType::CtorSprintf(), LITERAL("Hello, %d"), 42);
			VERIFY(str == LITERAL("Hello, 42"));
			VERIFY(str.validate());
		}

		{
			StringType str(typename StringType::CtorSprintf(), LITERAL("Hello, %d %d %d %d %d %d %d %d %d"), 42, 42, 42, 42, 42, 42, 42, 42, 42);
			VERIFY(str == LITERAL("Hello, 42 42 42 42 42 42 42 42 42"));
			VERIFY(str.validate());
		}
	#endif
	}

	// basic_string(std::initializer_list<value_type> init, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
	#if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
		StringType str({'a','b','c','d','e','f'});
		VERIFY(str == LITERAL("abcdef"));
		VERIFY(!str.empty());
		VERIFY(str.length() == 6);
		VERIFY(str.size() == 6);
		VERIFY(str.validate());
	#endif
	}

	// basic_string(this_type&& x);
	// basic_string(this_type&& x, const allocator_type& allocator);
	{  // test heap string
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2(eastl::move(str1));

		VERIFY(str1 != LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str2 == LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 26);

		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 26);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}
	{  // test sso string
		StringType str1(LITERAL("a"));
		StringType str2(eastl::move(str1));

		VERIFY(str1 != LITERAL("a"));
		VERIFY(str2 == LITERAL("a"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 1);

		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 1);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// basic_string(const view_type& sv, const allocator_type& allocator);
	// basic_string(const view_type& sv, size_type position, size_type n, const allocator_type& allocator);
	{
		{ // test string_view
			typename StringType::view_type sv(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			StringType str(sv);

			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
			VERIFY(!str.empty());
			VERIFY(str.length() == 26);
			VERIFY(str.size() == 26);
			VERIFY(str.validate());
		}

		{  // test string_view substring
			typename StringType::view_type sv(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			StringType str(sv, 2, 22);

			VERIFY(str == LITERAL("cdefghijklmnopqrstuvwx"));
			VERIFY(!str.empty());
			VERIFY(str.length() == 22);
			VERIFY(str.size() == 22);
			VERIFY(str.validate());
		}
	}

	// template <typename OtherCharType>
	// basic_string(CtorConvert, const OtherCharType* p, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(typename StringType::CtorConvert(), EA_CHAR8("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(typename StringType::CtorConvert(), EA_CHAR16("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(typename StringType::CtorConvert(), EA_CHAR32("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(typename StringType::CtorConvert(), EA_WCHAR("123456789"));
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherCharType>
	// basic_string(CtorConvert, const OtherCharType* p, size_type n, const allocator_type& allocator = EASTL_BASIC_STRING_DEFAULT_ALLOCATOR);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(typename StringType::CtorConvert(), EA_CHAR8("123456789"), 4);
			VERIFY(str == LITERAL("1234"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(typename StringType::CtorConvert(), EA_CHAR16("123456789"), 4);
			VERIFY(str == LITERAL("1234"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(typename StringType::CtorConvert(), EA_CHAR32("123456789"), 4);
			VERIFY(str == LITERAL("1234"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(typename StringType::CtorConvert(), EA_WCHAR("123456789"), 4);
		    VERIFY(str == LITERAL("1234"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherStringType>
	// basic_string(CtorConvert, const OtherStringType& x);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(typename StringType::CtorConvert(), eastl::basic_string<char8_t, typename StringType::allocator_type>(EA_CHAR8("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(typename StringType::CtorConvert(), eastl::basic_string<char16_t, typename StringType::allocator_type>(EA_CHAR16("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(typename StringType::CtorConvert(), eastl::basic_string<char32_t, typename StringType::allocator_type>(EA_CHAR32("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(typename StringType::CtorConvert(), eastl::basic_string<wchar_t, typename StringType::allocator_type>(EA_WCHAR("123456789")));
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// const allocator_type& get_allocator() const EA_NOEXCEPT;
	// allocator_type&       get_allocator() EA_NOEXCEPT;
	// void                  set_allocator(const allocator_type& allocator);
	{
	}

	// this_type& operator=(const this_type& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str1_copy(LITERAL(""));

		VERIFY(str1_copy.empty());

		str1_copy = str1;

		VERIFY(str1 == str1_copy);
		VERIFY(!str1_copy.empty());
		VERIFY(str1.validate());
		VERIFY(str1_copy.validate());
	}

	// this_type& operator=(const value_type* p);
	{
		StringType str;
		str = LITERAL("abcdefghijklmnopqrstuvwxyz");

		VERIFY(str[5] == LITERAL('f'));
		VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(!str.empty());
		VERIFY(str.length() == 26);
		VERIFY(str.validate());
	}

	// this_type& operator=(value_type c);
	{
		StringType str;
		str = LITERAL('a');

		VERIFY(str == LITERAL("a"));
		VERIFY(!str.empty());
		VERIFY(str.length() == 1);
		VERIFY(str.size() == 1);
		VERIFY(str.validate());
	}

	// this_type& operator=(std::initializer_list<value_type> ilist);
	{
	#if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
		StringType str = {'a','b','c','d','e','f'};

		VERIFY(str == LITERAL("abcdef"));
		VERIFY(!str.empty());
		VERIFY(str.length() == 6);
		VERIFY(str.size() == 6);
		VERIFY(str.validate());
	#endif
	}

	// this_type& operator=(this_type&& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2 = eastl::move(str1);

		VERIFY(str1 != LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str2 == LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 26);

		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 26);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}
	{
		StringType str1(LITERAL("a"));
		StringType str2 = eastl::move(str1);

		VERIFY(str1 != LITERAL("a"));
		VERIFY(str2 == LITERAL("a"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 1);

		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 1);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	//     this_type& operator=(value_type* p);
	//
	//     template <typename OtherCharType>
	//     this_type& operator=(const OtherCharType* p);
	//
	//     template <typename OtherStringType>
	//     this_type& operator=(const OtherStringType& x);
	{
	#if EASTL_OPERATOR_EQUALS_OTHER_ENABLED
		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str = LITERAL("123456789");
			VERIFY(str == LITERAL("123456789");
			VERIFY(str.validate());
		}
		{
			{
			#if defined(EA_CHAR8)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = EA_CHAR8("123456789");
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_CHAR16)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = EA_CHAR16("123456789");
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_CHAR32)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = EA_CHAR32("123456789");
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_WCHAR)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = EA_WCHAR("123456789");
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
		}
		{
			{
			#if defined(EA_CHAR8)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = eastl::basic_string<char8_t>(EA_CHAR8("123456789"));
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_CHAR16)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = eastl::basic_string<char16_t>(EA_CHAR16("123456789"));
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_CHAR32)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = eastl::basic_string<char32_t>(EA_CHAR32("123456789"));
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
			{
			#if defined(EA_WCHAR)
				StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
				str = eastl::basic_string<wchar_t>(EA_WCHAR("123456789"));
				VERIFY(str == LITERAL("123456789"));
				VERIFY(str.validate());
			#endif
			}
		}
    #endif
	}

	// void swap(this_type& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2;

		str1.swap(str2);

		VERIFY(str1 != LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str2 == LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 26);
		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 26);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// this_type& assign(const this_type& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2;

		str2.assign(str1);

		VERIFY(str1 == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str2 == LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(!str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 26);
		VERIFY(str2.length() == 26);
		VERIFY(str1.size() == 26);
		VERIFY(str2.size() == 26);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// this_type& assign(const this_type& x, size_type position, size_type n);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2(LITERAL("123456789"));

		str1.assign(str2, 3, 3);

		VERIFY(str1 == LITERAL("456"));
		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// this_type& assign(const value_type* p, size_type n);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.assign(LITERAL("123456789"), 5);

		VERIFY(str == LITERAL("12345"));
		VERIFY(str.validate());
	}

	// this_type& assign(const value_type* p);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.assign(LITERAL("123"));

		VERIFY(str == LITERAL("123"));
		VERIFY(str.validate());
	}

	// this_type& assign(size_type n, value_type c);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.assign(32, LITERAL('c'));

		VERIFY(str == LITERAL("cccccccccccccccccccccccccccccccc"));
		VERIFY(str.validate());
	}

	// this_type& assign(const value_type* pBegin, const value_type* pEnd);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto* pLiteral = LITERAL("0123456789");
		auto* pBegin = pLiteral + 4;
		auto* pEnd = pLiteral + 7;

		str.assign(pBegin, pEnd);

		VERIFY(str == LITERAL("456"));
		VERIFY(str.validate());
	}

	// this_type& assign(this_type&& x);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2;

		str1.assign(eastl::move(str2));

		VERIFY(str1 != LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str2 == LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str1.empty());
		VERIFY(!str2.empty());

		VERIFY(str1.length() == 0);
		VERIFY(str2.length() == 26);
		VERIFY(str1.size() == 0);
		VERIFY(str2.size() == 26);

		VERIFY(str1.validate());
		VERIFY(str2.validate());
	}

	// this_type& assign(std::initializer_list<value_type>);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.assign({'1','2','3'});

		VERIFY(str == LITERAL("123"));
		VERIFY(str.validate());
	}

	// template <typename OtherCharType>
	// this_type& assign_convert(const OtherCharType* p);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR8("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR16("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR32("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		    str.assign_convert(EA_WCHAR("123456789"));
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherCharType>
	// this_type& assign_convert(const OtherCharType* p, size_type n);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR8("123456789"), 3);
			VERIFY(str == LITERAL("123"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR16("123456789"), 3);
			VERIFY(str == LITERAL("123"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.assign_convert(EA_CHAR32("123456789"), 3);
			VERIFY(str == LITERAL("123"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		    str.assign_convert(EA_WCHAR("123456789"), 3);
		    VERIFY(str == LITERAL("123"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherStringType>
	// this_type& assign_convert(const OtherStringType& x);
	{
		{
		#if defined(EA_CHAR8)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			eastl::basic_string<char8_t> str2(EA_CHAR8("123456789"));

			str.assign_convert(str2);
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			eastl::basic_string<char16_t> str2(EA_CHAR16("123456789"));

			str.assign_convert(str2);
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			eastl::basic_string<char32_t> str2(EA_CHAR32("123456789"));

			str.assign_convert(str2);
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		    eastl::basic_string<wchar_t> str2(EA_WCHAR("123456789"));

		    str.assign_convert(str2);
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// iterator       begin() EA_NOEXCEPT;
	// const_iterator begin() const EA_NOEXCEPT;
	// const_iterator cbegin() const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto iBegin = str.begin();

		VERIFY(*iBegin++ == LITERAL('a'));
		VERIFY(*iBegin++ == LITERAL('b'));
		VERIFY(*iBegin++ == LITERAL('c'));
		VERIFY(*iBegin++ == LITERAL('d'));
		VERIFY(*iBegin++ == LITERAL('e'));
		VERIFY(*iBegin++ == LITERAL('f'));
		VERIFY(*(str.begin() + 25) == LITERAL('z'));

	}

	// iterator       end() EA_NOEXCEPT;
	// const_iterator end() const EA_NOEXCEPT;
	// const_iterator cend() const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto iEnd = str.end()-1;

		VERIFY(*iEnd-- == LITERAL('z'));
		VERIFY(*iEnd-- == LITERAL('y'));
		VERIFY(*iEnd-- == LITERAL('x'));
		VERIFY(*iEnd-- == LITERAL('w'));
		VERIFY(*iEnd-- == LITERAL('v'));
		VERIFY(*iEnd-- == LITERAL('u'));
		VERIFY(*(str.end() - 26) == LITERAL('a'));
	}

	// reverse_iterator       rbegin() EA_NOEXCEPT;
	// const_reverse_iterator rbegin() const EA_NOEXCEPT;
	// const_reverse_iterator crbegin() const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto iRBegin = str.rbegin();

		VERIFY(*iRBegin++ == LITERAL('z'));
		VERIFY(*iRBegin++ == LITERAL('y'));
		VERIFY(*iRBegin++ == LITERAL('x'));
		VERIFY(*iRBegin++ == LITERAL('w'));
		VERIFY(*iRBegin++ == LITERAL('v'));
		VERIFY(*iRBegin++ == LITERAL('u'));
		VERIFY(*(str.rbegin() + 25) == LITERAL('a'));
	}

	// reverse_iterator       rend() EA_NOEXCEPT;
	// const_reverse_iterator rend() const EA_NOEXCEPT;
	// const_reverse_iterator crend() const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto iREnd = str.rend() - 1;

		VERIFY(*iREnd-- == LITERAL('a'));
		VERIFY(*iREnd-- == LITERAL('b'));
		VERIFY(*iREnd-- == LITERAL('c'));
		VERIFY(*iREnd-- == LITERAL('d'));
		VERIFY(*iREnd-- == LITERAL('e'));
		VERIFY(*iREnd-- == LITERAL('f'));
		VERIFY(*(str.rend() - 26) == LITERAL('z'));
	}

	// bool empty() const EA_NOEXCEPT;
	// size_type size() const EA_NOEXCEPT;
	// size_type length() const EA_NOEXCEPT;
	// size_type capacity() const EA_NOEXCEPT;
	// void resize(size_type n, value_type c);
	// void resize(size_type n);
	// void set_capacity(size_type n = npos);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(!str.empty());
		VERIFY(str.size() == 26);
		VERIFY(str.length() == 26);
		VERIFY(str.capacity() >= 26);

		str.assign(LITERAL(""));
		VERIFY(str.empty());
		VERIFY(str.size() == 0);
		VERIFY(str.length() == 0);
		VERIFY(str.capacity() >= 26);  // should not free existing capacity

		str.resize(0);
		VERIFY(str.empty());
		VERIFY(str.size() == 0);
		VERIFY(str.length() == 0);
		VERIFY(str.capacity() >= 26);  // should not free existing capacity

		str.set_capacity(0);
		// VERIFY(str.capacity() == 0); // frees existing capacity, but has a minimun of SSO capacity

		str.resize(32, LITERAL('c'));
		VERIFY(!str.empty());
		VERIFY(str.size() == 32);
		VERIFY(str.length() == 32);
		VERIFY(str.capacity() >= 32);
		VERIFY(str == LITERAL("cccccccccccccccccccccccccccccccc"));
	}

	// void shrink_to_fit
	{
		SSOStringType str(LITERAL("a"));
		str.reserve(100);
		VERIFY(str.capacity() == 100);
		str.shrink_to_fit();
		// string should shrink to SSO
		VERIFY(str.IsSSO());

		str = LITERAL("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); // 32 characters
		str.reserve(100);
		VERIFY(str.capacity() == 100);
		str.shrink_to_fit();
		// string should shrink but still be heap
		VERIFY(str.capacity() == 32);
		VERIFY(!str.IsSSO());
	}

	// void set_capacity(n)
	{
		const auto *pLiteral32 = LITERAL("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
		const auto *pLiteral31 = LITERAL("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
		const auto *pLiteral1 = LITERAL("a");
		const auto *pLiteral2 = LITERAL("aa");

		SSOStringType str = pLiteral32;
		// set_capacity(0) - deallocate and reset to SSO;
		{
			// heap -> sso
			VERIFY(!str.IsSSO());
			str.set_capacity(0);
			VERIFY(str.IsSSO());
			VERIFY(str == LITERAL(""));
		}
		{
			// sso -> sso
			str = pLiteral1;
			VERIFY(str.IsSSO());
			str.set_capacity(0);
			VERIFY(str.IsSSO());
			VERIFY(str == LITERAL(""));
		}

		// set_capacity(npos) - set capacity equal to current size - should realloc
		{
			// heap -> heap
			str = pLiteral32;
			str.reserve(100);
			VERIFY(!str.IsSSO());
			VERIFY(str.capacity() == 100);
			str.set_capacity(StringType::npos);
			VERIFY(!str.IsSSO());
			VERIFY(str.capacity() == 32);
			VERIFY(str == pLiteral32);
		}
		{
			// heap -> sso
			str = pLiteral1;
			str.reserve(100);
			VERIFY(!str.IsSSO());
			VERIFY(str.capacity() == 100);
			str.set_capacity(StringType::npos);
			VERIFY(str.IsSSO());
			VERIFY(str == pLiteral1);
		}
		{
			// sso -> sso
			str = pLiteral1;
			VERIFY(str.IsSSO());
			str.set_capacity(StringType::npos);
			VERIFY(str.IsSSO());
			VERIFY(str == pLiteral1);
		}

		// set_capacity(n > capacity) - set capacity greater than out current capacity
		{
			// heap -> heap
			str = pLiteral32;
			VERIFY(!str.IsSSO());
			auto nSavedCap = str.capacity();
			str.set_capacity(nSavedCap + 1);
			VERIFY(!str.IsSSO());
			VERIFY(str == pLiteral32);
			VERIFY(str.capacity() > nSavedCap);
		}
		{
			// sso -> heap
			str.set_capacity(0); // reset to sso
			str = pLiteral1;
			VERIFY(str.IsSSO());
			auto nSavedCap = str.capacity();
			str.set_capacity(nSavedCap + 1);
			VERIFY(!str.IsSSO());
			VERIFY(str == pLiteral1);
			VERIFY(str.capacity() > nSavedCap);
		}
		{
			// sso -> sso
			str.set_capacity(0); // reset to sso
			str = pLiteral1;
			VERIFY(str.IsSSO());
			auto nSavedCap = str.capacity();
			str.set_capacity(str.size() + 1);
			VERIFY(str.IsSSO());
			VERIFY(str == pLiteral1);
			VERIFY(str.capacity() == nSavedCap);
		}

		// set_capacity(n < size) - set capacity less than current size, str should truncate
		{
			// sso -> sso
			str = pLiteral2;
			VERIFY(str.IsSSO());
			str.set_capacity(1);
			VERIFY(str.IsSSO());
			VERIFY(str == pLiteral1);
		}
		{
			// heap -> sso
			str = pLiteral32;
			VERIFY(!str.IsSSO());
			str.set_capacity(1);
			VERIFY(str.IsSSO());
			VERIFY(str == pLiteral1);
		}
		{
			// heap -> heap
			str = pLiteral32;
			VERIFY(!str.IsSSO());
			str.set_capacity(31);
			VERIFY(!str.IsSSO());
			VERIFY(str == pLiteral31);
		}
	}

	// void reserve(size_type = 0);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(!str.empty());
		VERIFY(str.size() == 26);
		VERIFY(str.length() == 26);
		VERIFY(str.capacity() >= 26);

		// verifies that we allocate memory
		str.reserve(64);
		VERIFY(!str.empty());
		VERIFY(str.size() == 26);
		VERIFY(str.length() == 26);
		VERIFY(str.capacity() >= 64);

		// verifies that we do not free memory
		str.reserve(32);
		VERIFY(!str.empty());
		VERIFY(str.size() == 26);
		VERIFY(str.length() == 26);
		VERIFY(str.capacity() >= 64);
	}

	// void force_size(size_type n);
	{
		// force_size does not write terminating null, meant to set size when using external
		// string writing mnethods like strcpy or sprintf
		StringType str(LITERAL("aaa"));
		VERIFY(str.size() == 3);
		str.force_size(0);
		VERIFY(str.size() == 0);
		str.reserve(4); // 32 bit platform with char32_t can only hold 2 characters
		str.force_size(4);
		VERIFY(str.size() == 4);
		str[4] = '0';
		str = LITERAL("aaa");
		VERIFY(str.size() == 3);
	}

	// const value_type* data() const EA_NOEXCEPT;
	// const value_type* c_str() const EA_NOEXCEPT;
	{
		const StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		const typename StringType::value_type* pData = str.data();
		const typename StringType::value_type* pCStr = str.c_str();

		VERIFY(pData != nullptr);
		VERIFY(pCStr != nullptr);
		VERIFY(pData == pCStr);
		VERIFY(EA::StdC::Memcmp(pData, pCStr, str.size()) == 0);
	}

	// value_type* data() EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		typename StringType::value_type* pData = str.data();

		VERIFY(pData != nullptr);
		VERIFY(EA::StdC::Memcmp(pData, LITERAL("abcdefghijklmnopqrstuvwxyz"), str.size()) == 0);
	}

	// reference       operator[](size_type n);
	// const_reference operator[](size_type n) const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str[0]  == LITERAL('a'));
		VERIFY(str[14] == LITERAL('o'));
		VERIFY(str[25] == LITERAL('z'));
	}

	// reference       at(size_type n);
	// const_reference at(size_type n) const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str.at(0)  == LITERAL('a'));
		VERIFY(str.at(14) == LITERAL('o'));
		VERIFY(str.at(25) == LITERAL('z'));
	}

	// reference       front();
	// const_reference front() const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str.front()  == LITERAL('a'));
	}

	// reference       back();
	// const_reference back() const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		VERIFY(str.back()  == LITERAL('z'));
	}

	// this_type& operator+=(const this_type& x);
	// this_type& operator+=(const value_type* p);
	// this_type& operator+=(value_type c);
	{
		StringType str1(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		StringType str2(LITERAL("123"));
		str1 += str2;
		str1 += LITERAL("456");
		str1 += LITERAL('7');

		VERIFY(str1 == LITERAL("abcdefghijklmnopqrstuvwxyz1234567"));
	}

	// this_type& append(const this_type& x);
	// this_type& append(const this_type& x, size_type position, size_type n);
	// this_type& append(const value_type* p, size_type n);
	// this_type& append(const value_type* p);
	// this_type& append(size_type n, value_type c);
	// this_type& append(const value_type* pBegin, const value_type* pEnd);
	{
		const StringType src(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		StringType str;
		str.append(StringType(LITERAL("abcd")));        // "abcd"
		str.append(src, 4, 4); 		   					// "abcdefgh"
		str.append(src.data() + 8, 4); 					// "abcdefghijkl"
		str.append(LITERAL("mnop"));   					// "abcdefghijklmnop"
		str.append(1, LITERAL('q'));   					// "abcdefghijklmnopq"
		str.append(src.data() + 17, src.data() + 26);   // "abcdefghijklmnopqrstuvwxyz"

		VERIFY(str == src);
	}

	// this_type& append_sprintf_va_list(const value_type* pFormat, va_list arguments);
	// this_type& append_sprintf(const value_type* pFormat, ...);
	{
	#if EASTL_SNPRINTF_TESTS_ENABLED
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.append_sprintf(LITERAL("Hello, %d"), 42);

		VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyzHello, 42"));
		VERIFY(str.validate());
	#endif
	}

	// template <typename OtherCharType>
	// this_type& append_convert(const OtherCharType* p);
	{
		{
		#if defined(EA_CHAR8)
			StringType str;
			str.append_convert(EA_CHAR8("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str;
			str.append_convert(EA_CHAR16("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str;
			str.append_convert(EA_CHAR32("123456789"));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str;
		    str.append_convert(EA_WCHAR("123456789"));
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherCharType>
	// this_type& append_convert(const OtherCharType* p, size_type n);
	{
		{
		#if defined(EA_CHAR8)
			StringType str;
			str.append_convert(EA_CHAR8("123456789"), 5);
			VERIFY(str == LITERAL("12345"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str;
			str.append_convert(EA_CHAR16("123456789"), 5);
			VERIFY(str == LITERAL("12345"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str;
			str.append_convert(EA_CHAR32("123456789"), 5);
			VERIFY(str == LITERAL("12345"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str;
		    str.append_convert(EA_WCHAR("123456789"), 5);
		    VERIFY(str == LITERAL("12345"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// template <typename OtherStringType>
	// this_type& append_convert(const OtherStringType& x);
	{
		{
		#if defined(EA_CHAR8)
			StringType str; 
			str.append_convert(eastl::u8string(EA_CHAR8("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR16)
			StringType str; 
			str.append_convert(eastl::string16(EA_CHAR16("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_CHAR32)
			StringType str;
			str.append_convert(eastl::string32(EA_CHAR32("123456789")));
			VERIFY(str == LITERAL("123456789"));
			VERIFY(str.validate());
		#endif
		}
		{
		#if defined(EA_WCHAR)
		    StringType str;
		    str.append_convert(eastl::wstring(EA_WCHAR("123456789")));
		    VERIFY(str == LITERAL("123456789"));
		    VERIFY(str.validate());
		#endif
		}
	}

	// void push_back(value_type c);
	{
		StringType str;
		const StringType src(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		eastl::for_each(eastl::begin(src), eastl::end(src), [&str](const typename StringType::value_type& c)
		                { str.push_back(c); });

		VERIFY(str == src);
		VERIFY(str.validate());
	}

	// void pop_back();
	{
		StringType str(LITERAL("123456789"));
		VERIFY(str == LITERAL("123456789"));

		str.pop_back(); VERIFY(str == LITERAL("12345678"));
		str.pop_back(); VERIFY(str == LITERAL("1234567"));
		str.pop_back(); VERIFY(str == LITERAL("123456"));
		str.pop_back(); VERIFY(str == LITERAL("12345"));
		str.pop_back(); VERIFY(str == LITERAL("1234"));
		str.pop_back(); VERIFY(str == LITERAL("123"));
		str.pop_back(); VERIFY(str == LITERAL("12"));
		str.pop_back(); VERIFY(str == LITERAL("1"));
		str.pop_back(); VERIFY(str == LITERAL(""));

		VERIFY(str.validate());
	}

	// this_type& insert(size_type position, const this_type& x);
	// this_type& insert(size_type position, const this_type& x, size_type beg, size_type n);
	// this_type& insert(size_type position, const value_type* p, size_type n);
	// this_type& insert(size_type position, const value_type* p);
	// this_type& insert(size_type position, size_type n, value_type c);
	// iterator insert(const_iterator p, value_type c);
	// iterator insert(const_iterator p, size_type n, value_type c);
	// iterator insert(const_iterator p, const value_type* pBegin, const value_type* pEnd);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		str.insert((typename StringType::size_type)0, (typename StringType::size_type)1, LITERAL('1'));   // todo: elminiate the cast to disambiguate
		VERIFY(str == LITERAL("1abcdefghijklmnopqrstuvwxyz"));

		str.insert(2, LITERAL("234"));
		VERIFY(str == LITERAL("1a234bcdefghijklmnopqrstuvwxyz"));

		str.insert(15, StringType(LITERAL("567")));
		VERIFY(str == LITERAL("1a234bcdefghijk567lmnopqrstuvwxyz"));

		str.insert(30, StringType(LITERAL(" is an example of a substring")), 1, 14);
		VERIFY(str == LITERAL("1a234bcdefghijk567lmnopqrstuvwis an example xyz"));

		{
			StringType strSSO;
			auto nSSOCap = strSSO.capacity();
			StringType strCheck;
			strCheck.append(nSSOCap, LITERAL('a'));

			strSSO.append(nSSOCap - 1, LITERAL('a'));

			strSSO.insert(strSSO.size() - 1, LITERAL("a"));
			VERIFY(strSSO.validate());
			VERIFY(strSSO == strCheck);
		}

		{
			StringType strSSO;
			auto nSSOCap = strSSO.capacity();

			// 32 bit platform with char32_t can only hold 2 characters in SSO
			if (nSSOCap - 2 > 0)
			{
				StringType strCheck;
				strCheck.append(nSSOCap, LITERAL('a'));

				strSSO.append(nSSOCap - 2, LITERAL('a'));

				strSSO.insert(strSSO.size() - 1, LITERAL("aa"));
				VERIFY(strSSO.validate());
				VERIFY(strSSO == strCheck);
			}
		}
	}

	// iterator insert(const_iterator p, std::initializer_list<value_type>);
	{
	#if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
		StringType str;
		str.insert(str.begin(),     {'a','b','c'});
		str.insert(str.end(),       {'d','e','f'});
		str.insert(str.begin() + 3, {'1','2','3'});

		VERIFY(str == LITERAL("abc123def"));
		VERIFY(str.validate());
	#endif
	}

	// insert(const_iterator p, value_type c)
	{
		StringType str = LITERAL("aaa");
		auto it = str.insert(str.end(), 'b');
		VERIFY(*it == LITERAL('b'));
		VERIFY(str == LITERAL("aaab"));
		it = str.insert(str.begin(), 'c');
		VERIFY(*it == LITERAL('c'));
		VERIFY(str == LITERAL("caaab"));
		it = str.insert(str.begin() + 2, 'd');
		VERIFY(*it == LITERAL('d'));
		VERIFY(str == LITERAL("cadaab"));
	}

	// this_type&       erase(size_type position = 0, size_type n = npos);
	// iterator         erase(const_iterator p);
	// iterator         erase(const_iterator pBegin, const_iterator pEnd);
	// reverse_iterator erase(reverse_iterator position);
	// reverse_iterator erase(reverse_iterator first, reverse_iterator last);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		str.erase(0,5);
		VERIFY(str == LITERAL("fghijklmnopqrstuvwxyz"));

		str.erase(5,10);
		VERIFY(str == LITERAL("fghijuvwxyz"));

		str.erase(str.find(LITERAL('v')));
		VERIFY(str == LITERAL("fghiju"));

		str.erase(str.find(LITERAL('g')), str.find(LITERAL('i')));
		VERIFY(str == LITERAL("fju"));

		typename StringType::const_iterator it = str.begin() + 1; // 'j'
		str.erase(it);
		VERIFY(str == LITERAL("fu"));

	}

	// void clear() EA_NOEXCEPT;
	{
		StringType str(LITERAL("123456789"));
		VERIFY(str == LITERAL("123456789"));

		str.clear();
		VERIFY(str == LITERAL(""));
		VERIFY(str.empty());
		VERIFY(str.validate());
	}


	// pointer detach() EA_NOEXCEPT;
	{
		{
			// Heap
			auto* pLiteral = LITERAL("abcdefghijklmnopqrstuvwxyz");
			StringType str(pLiteral);
			const auto sz = str.size() + 1;  // +1 for null-terminator

			auto* pDetach = str.detach();

			VERIFY(pDetach != nullptr);
			VERIFY(EA::StdC::Strcmp(pDetach, pLiteral) == 0);
			VERIFY(pDetach != pLiteral);
			VERIFY(str.empty());
			VERIFY(str.size() == 0);

			str.get_allocator().deallocate(pDetach, sz);
		}

		{
			// SSO
			auto* pLiteral = LITERAL("a");
			StringType str(pLiteral);
			const auto sz = str.size() + 1;  // +1 for null-terminator

			auto* pDetach = str.detach();

			VERIFY(pDetach != nullptr);
			VERIFY(EA::StdC::Strcmp(pDetach, pLiteral) == 0);
			VERIFY(pDetach != pLiteral);
			VERIFY(str.empty());
			VERIFY(str.size() == 0);

			str.get_allocator().deallocate(pDetach, sz);
		}

		{
			// SSO, empty string
			auto* pLiteral = LITERAL("");
			StringType str(pLiteral);
			const auto sz = str.size() + 1;  // +1 for null-terminator

			auto* pDetach = str.detach();

			VERIFY(pDetach != nullptr);
			VERIFY(EA::StdC::Strcmp(pDetach, pLiteral) == 0);
			VERIFY(pDetach != pLiteral);
			VERIFY(str.empty());
			VERIFY(str.size() == 0);

			str.get_allocator().deallocate(pDetach, sz);
		}

		{
			// SSO, empty string via default ctor
			StringType str;
			const auto sz = str.size() + 1;  // +1 for null-terminator

			auto* pDetach = str.detach();

			VERIFY(pDetach != nullptr);
			VERIFY(pDetach[0] == 0);
			VERIFY(str.empty());
			VERIFY(str.size() == 0);

			str.get_allocator().deallocate(pDetach, sz);
		}
	}

	// this_type&  replace(size_type position, size_type n, const this_type& x);
	// this_type&  replace(size_type pos1, size_type n1, const this_type& x, size_type pos2, size_type n2);
	// this_type&  replace(size_type position, size_type n1, const value_type* p, size_type n2);
	// this_type&  replace(size_type position, size_type n1, const value_type* p);
	// this_type&  replace(size_type position, size_type n1, size_type n2, value_type c);
	// this_type&  replace(const_iterator first, const_iterator last, const this_type& x);
	// this_type&  replace(const_iterator first, const_iterator last, const value_type* p, size_type n);
	// this_type&  replace(const_iterator first, const_iterator last, const value_type* p);
	// this_type&  replace(const_iterator first, const_iterator last, size_type n, value_type c);
	// this_type&  replace(const_iterator first, const_iterator last, const value_type* pBegin, const value_type* pEnd);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		str.replace(5, 10, StringType(LITERAL("123")));
		VERIFY(str == LITERAL("abcde123pqrstuvwxyz"));

		str.replace(13, 1, StringType(LITERAL("0123456789")), 4, 6 );
		VERIFY(str == LITERAL("abcde123pqrst456789vwxyz"));

		str.replace(24, 1, LITERAL("0123456789"));
		VERIFY(str == LITERAL("abcde123pqrst456789vwxyz0123456789"));

		str.replace(16, 4, 4, LITERAL('@'));
		VERIFY(str == LITERAL("abcde123pqrst456@@@@wxyz0123456789"));
	}

	// size_type copy(value_type* p, size_type n, size_type position = 0) const;
	{
		typename StringType::value_type buf[64];

		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		str.copy(buf, 10, 10);

		VERIFY(EA::StdC::Memcmp(buf, LITERAL("klmnopqrst"), 10) == 0);
	}

	// size_type find(const this_type& x, size_type position = 0) const EA_NOEXCEPT;
	// size_type find(const value_type* p, size_type position = 0) const;
	// size_type find(const value_type* p, size_type position, size_type n) const;
	// size_type find(value_type c, size_type position = 0) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str.find(StringType(LITERAL("d")))    != StringType::npos);
		VERIFY(str.find(StringType(LITERAL("tuv")))  != StringType::npos);
		VERIFY(str.find(StringType(LITERAL("123r"))) == StringType::npos);

		VERIFY(str.find(LITERAL("d"))    != StringType::npos);
		VERIFY(str.find(LITERAL("tuv"))  != StringType::npos);
		VERIFY(str.find(LITERAL("123r")) == StringType::npos);

		VERIFY(str.find(LITERAL("d"), 0)    != StringType::npos);
		VERIFY(str.find(LITERAL("tuv"), 2)  != StringType::npos);
		VERIFY(str.find(LITERAL("123r"), 2) == StringType::npos);

		VERIFY(str.find(LITERAL('d'), 0) != StringType::npos);
		VERIFY(str.find(LITERAL('t'), 2) != StringType::npos);
		VERIFY(str.find(LITERAL('1'), 2) == StringType::npos);
	}

	// size_type rfind(const this_type& x, size_type position = npos) const EA_NOEXCEPT;
	// size_type rfind(const value_type* p, size_type position = npos) const;
	// size_type rfind(const value_type* p, size_type position, size_type n) const;
	// size_type rfind(value_type c, size_type position = npos) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str.rfind(StringType(LITERAL("d")))    != StringType::npos);
		VERIFY(str.rfind(StringType(LITERAL("tuv")))  != StringType::npos);
		VERIFY(str.rfind(StringType(LITERAL("123r"))) == StringType::npos);

		VERIFY(str.rfind(LITERAL("d"))    != StringType::npos);
		VERIFY(str.rfind(LITERAL("tuv"))  != StringType::npos);
		VERIFY(str.rfind(LITERAL("123r")) == StringType::npos);

		VERIFY(str.rfind(LITERAL("d"), 20)    != StringType::npos);
		VERIFY(str.rfind(LITERAL("tuv"), 20)  != StringType::npos);
		VERIFY(str.rfind(LITERAL("123r"), 20) == StringType::npos);

		VERIFY(str.rfind(LITERAL('d'), 20) != StringType::npos);
		VERIFY(str.rfind(LITERAL('t'), 20) != StringType::npos);
		VERIFY(str.rfind(LITERAL('1'), 20) == StringType::npos);
	}

	// size_type find_first_of(const this_type& x, size_type position = 0) const EA_NOEXCEPT;
	// size_type find_first_of(const value_type* p, size_type position = 0) const;
	// size_type find_first_of(const value_type* p, size_type position, size_type n) const;
	// size_type find_first_of(value_type c, size_type position = 0) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("aaaaabbbbbcccdddddeeeeefffggh"));

		VERIFY(str.find_first_of(StringType(LITERAL("aaa"))) == 0);
		VERIFY(str.find_first_of(LITERAL("aab")) == 0);
		VERIFY(str.find_first_of(LITERAL("baab")) == 0);
		VERIFY(str.find_first_of(LITERAL("ceg")) == 10);
		VERIFY(str.find_first_of(LITERAL("eeef"), 1, 2) == 18);
		VERIFY(str.find_first_of(LITERAL("eeef"), 1, 4) == 18);
		VERIFY(str.find_first_of(LITERAL('g')) == 26);
		VERIFY(str.find_first_of(LITERAL('$')) == StringType::npos);
	}

	// size_type find_last_of(const this_type& x, size_type position = npos) const EA_NOEXCEPT;
	// size_type find_last_of(const value_type* p, size_type position = npos) const;
	// size_type find_last_of(const value_type* p, size_type position, size_type n) const;
	// size_type find_last_of(value_type c, size_type position = npos) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("aaaaabbbbbcccdddddeeeeefffggh"));

		VERIFY(str.find_last_of(StringType(LITERAL("aaa"))) == 4);
		VERIFY(str.find_last_of(LITERAL("aab")) == 9);
		VERIFY(str.find_last_of(LITERAL("baab")) == 9);
		VERIFY(str.find_last_of(LITERAL("ceg")) == 27);
		// VERIFY(str.find_last_of(LITERAL("eeef"), 1, 2) == StringType::npos);  // todo: FIX ME
		// VERIFY(str.find_last_of(LITERAL("eeef"), 1, 4) == StringType::npos);  // todo: FIX ME
		VERIFY(str.find_last_of(LITERAL('g')) == 27);
		VERIFY(str.find_last_of(LITERAL('$')) == StringType::npos);
	}

	// size_type find_first_not_of(const this_type& x, size_type position = 0) const EA_NOEXCEPT;
	// size_type find_first_not_of(const value_type* p, size_type position = 0) const;
	// size_type find_first_not_of(const value_type* p, size_type position, size_type n) const;
	// size_type find_first_not_of(value_type c, size_type position = 0) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("aaaaabbbbbcccdddddeeeeefffggh"));

		VERIFY(str.find_first_not_of(StringType(LITERAL("abcdfg"))) == 18);
		VERIFY(str.find_first_not_of(LITERAL("abcdfg")) == 18);
		// VERIFY(str.find_first_not_of(LITERAL("abcdfg"), 2, 2) == 0);   // todo:  FIX ME
		// VERIFY(str.find_first_not_of(LITERAL("abcdfg"), 0, 2) == 10);  // todo:  FIX ME
		VERIFY(str.find_first_not_of(LITERAL('a')) == 5);
	}

	// size_type find_last_not_of(const this_type& x,  size_type position = npos) const EA_NOEXCEPT;
	// size_type find_last_not_of(const value_type* p, size_type position = npos) const;
	// size_type find_last_not_of(const value_type* p, size_type position, size_type n) const;
	// size_type find_last_not_of(value_type c, size_type position = npos) const EA_NOEXCEPT;
	{
		StringType str(LITERAL("aaaaabbbbbcccdddddeeeeefffggh"));

		VERIFY(str.find_last_not_of(StringType(LITERAL("a"))) == 28);
		VERIFY(str.find_last_not_of(StringType(LITERAL("abcdfg"))) == 28);
		VERIFY(str.find_last_not_of(StringType(LITERAL("abcdfgh"))) == 22);
		VERIFY(str.find_last_not_of(LITERAL("abcdfgh")) == 22);
		// VERIFY(str.find_last_not_of(LITERAL("abcdfg"), 2, 2) == 0);   // todo:  FIX ME
		// VERIFY(str.find_last_not_of(LITERAL("abcdfg"), 0, 2) == 10);  // todo:  FIX ME
		VERIFY(str.find_last_not_of(LITERAL('a')) == 28);
	}

	// this_type substr(size_type position = 0, size_type n = npos) const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto substring = str.substr(0, 6);
		VERIFY(substring == LITERAL("abcdef"));

		substring = str.substr(0, 0);
		VERIFY(substring == LITERAL(""));

		substring = str.substr(16, 0);
		VERIFY(substring == LITERAL(""));

		substring = str.substr(16, 42);
		VERIFY(substring == LITERAL("qrstuvwxyz"));
	}

	// int        compare(const this_type& x) const EA_NOEXCEPT;
	// int        compare(size_type pos1, size_type n1, const this_type& x) const;
	// int        compare(size_type pos1, size_type n1, const this_type& x, size_type pos2, size_type n2) const;
	// int        compare(const value_type* p) const;
	// int        compare(size_type pos1, size_type n1, const value_type* p) const;
	// int        compare(size_type pos1, size_type n1, const value_type* p, size_type n2) const;
	// static int compare(const value_type* pBegin1, const value_type* pEnd1, const value_type* pBegin2, const value_type* pEnd2);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str.compare(StringType(LITERAL("abcdefghijklmnopqrstuvwxyz"))) == 0);
		VERIFY(str.compare(StringType(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))) != 0);
		VERIFY(str.compare(StringType(LITERAL("abcdefghijklmnopqrstuvwxyz123"))) != 0);
		VERIFY(str.compare(LITERAL("abcdefghijklmnopqrstuvwxyz")) == 0);
		VERIFY(str.compare(LITERAL("abcdefghijklmnopqrstuvwxyz123")) != 0);
		VERIFY(str.compare(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ123")) != 0);
	}

	// int        comparei(const this_type& x) const EA_NOEXCEPT;
	// int        comparei(const value_type* p) const;
	// static int comparei(const value_type* pBegin1, const value_type* pEnd1, const value_type* pBegin2, const value_type* pEnd2);
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		VERIFY(str.comparei(StringType(LITERAL("abcdefghijklmnopqrstuvwxyz"))) == 0);
		VERIFY(str.comparei(StringType(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))) == 0);
		VERIFY(str.comparei(StringType(LITERAL("abcdefghijklmnopqrstuvwxyz123"))) != 0);
		VERIFY(str.comparei(LITERAL("abcdefghijklmnopqrstuvwxyz")) == 0);
		VERIFY(str.comparei(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ")) == 0);
		VERIFY(str.comparei(LITERAL("abcdefghijklmnopqrstuvwxyz123")) != 0);
	}

	// void make_lower();
	{
		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.make_lower();
			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		}
		{
			StringType str(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
			str.make_lower();
			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		}
		{
			StringType str(LITERAL("123456789~!@#$%^&*()_+"));
			str.make_lower();
			VERIFY(str == LITERAL("123456789~!@#$%^&*()_+"));
		}
	}

	// void make_upper();
	{
		{
			StringType str(LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
			str.make_upper();
			VERIFY(str == LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
		}
		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			str.make_upper();
			VERIFY(str == LITERAL("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
		}
		{
			StringType str(LITERAL("123456789~!@#$%^&*()_+"));
			str.make_upper();
			VERIFY(str == LITERAL("123456789~!@#$%^&*()_+"));
		}
	}

	// void ltrim();
	// void rtrim();
	// void trim();
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		{
			StringType rstr(LITERAL("abcdefghijklmnopqrstuvwxyz			\t		\t\t\t		"));
			rstr.ltrim();
			VERIFY(str != rstr);
		}
		{
			StringType lstr(LITERAL("	\t						abcdefghijklmnopqrstuvwxyz"));
			lstr.ltrim();
			VERIFY(str == lstr);
		}
		{
			StringType rstr(LITERAL("abcdefghijklmnopqrstuvwxyz		\t\t\t					"));
			rstr.rtrim();
			VERIFY(str == rstr);
		}
		{
			StringType lstr(LITERAL("	\t						abcdefghijklmnopqrstuvwxyz"));
			lstr.rtrim();
			VERIFY(str != lstr);
		}
		{
			StringType lrstr(LITERAL("   \t                abcdefghijklmnopqrstuvwxyz		\t					"));
			lrstr.trim();
			VERIFY(str == lrstr);
		}
		{
			auto* pLiteral = LITERAL("abcdefghijklmn          opqrstuvwxyz");
			StringType mstr(pLiteral);
			mstr.trim();
			VERIFY(mstr == pLiteral);
		}
	}

	// void ltrim("a");
	// void rtrim("b");
	// void trim("?");
	{
		StringType expected(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		{
			const auto source = LITERAL("abcdefghijklmnopqrstuvwxyz                                         ");

			StringType rstr(source);
			rstr.ltrim(LITERAL(" "));
			VERIFY(rstr == source);  

			rstr.rtrim(LITERAL(" "));
			VERIFY(expected == rstr);
		}

		{
			const auto source = LITERAL("abcdefghijklmnopqrstuvwxyz			\t		\t\t\t		");

			StringType rstr(source);
			rstr.ltrim(LITERAL(" \t"));
			VERIFY(rstr == source);

			rstr.rtrim(LITERAL(" \t"));
			VERIFY(expected == rstr);
		}

		{
			const auto source = LITERAL(" \t		\t\t\t		abcdefghijklmnopqrstuvwxyz");

			StringType rstr(source);
			rstr.rtrim(LITERAL(" \t"));
			VERIFY(rstr == source);

			rstr.ltrim(LITERAL(" \t"));
			VERIFY(expected == rstr);
		}

		{
			const auto source = LITERAL("$$$%$$$$$$%$$$$$$$$$%$$$$$$$$abcdefghijklmnopqrstuvwxyz*********@*****************@******");
			StringType rstr(source);
			rstr.trim(LITERAL("^("));
			VERIFY(rstr == source);
		}

		{
			const auto source = LITERAL("$$$%$$$$$$%$$$$$$$$$%$$$$$$$$abcdefghijklmnopqrstuvwxyz*********@*****************@******");
			StringType rstr(source);
			rstr.rtrim(LITERAL("@*"));

			VERIFY(expected != rstr);
			VERIFY(rstr == LITERAL("$$$%$$$$$$%$$$$$$$$$%$$$$$$$$abcdefghijklmnopqrstuvwxyz"));

			rstr.ltrim(LITERAL("$%"));
			VERIFY(expected == rstr);
		}

		{
			const auto source = LITERAL("abcdefghijklmnopqrstuvwxyz**********************************");
			StringType rstr(source);
			rstr.ltrim(LITERAL("*"));
			VERIFY(expected != source);
		}

		{
			const auto source = LITERAL("           ?      abcdefghijklmnopqrstuvwxyz**********************************");
			StringType rstr(source);
			rstr.trim(LITERAL("*? "));
			VERIFY(expected != source);
		}
	}

	// this_type left(size_type n) const;
	// this_type right(size_type n) const;
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));

		auto lstr = str.left(6);
		VERIFY(lstr == LITERAL("abcdef"));

		auto rstr = str.right(8);
		VERIFY(rstr == LITERAL("stuvwxyz"));
	}

	// this_type& sprintf_va_list(const value_type* pFormat, va_list arguments);
	// this_type& sprintf(const value_type* pFormat, ...);
	{
	#if EASTL_SNPRINTF_TESTS_ENABLED
		StringType str(LITERAL(""));

		str.sprintf(LITERAL("Hello, %d"), 42);
		VERIFY(str == LITERAL("Hello, 42"));
	#endif
	}

	// void force_size(size_type n);
	{
		StringType str(LITERAL(""));
		str.reserve(10);

		auto p = const_cast<typename StringType::value_type*>(str.data());
		p[0] = 'a';
		p[1] = 'a';
		p[2] = 'a';
		p[3] = '\0';

		str.force_size(3);

		VERIFY(str.size() == 3);
		VERIFY(str.validate());
		VERIFY(!str.empty());
	}

	// test basic_string implicit conversion to basic_string_view
	// 		eastl::string implicitly converts to eastl::string_view.
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		[&](basic_string_view<typename StringType::value_type> sv)  // simulate api that requires eastl::string_view.
		{
			VERIFY(sv.compare(LITERAL("abcdefghijklmnopqrstuvwxyz")) == 0);
		}(str);
	}

	// test constructing a eastl::basic_string from an eastl::basic_string_view
	{
		using StringViewType = basic_string_view<typename StringType::value_type>;
		StringViewType sv = LITERAL("abcdefghijklmnopqrstuvwxyz");

		{
			StringType str(sv);
			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		}

		{
			StringType str(sv, typename StringType::allocator_type("test"));
			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		}

		{
			StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
			VERIFY(sv == str);
		}
    }

	// test assigning from an eastl::basic_string_view
	{
		using StringViewType = basic_string_view<typename StringType::value_type>;
		StringViewType sv = LITERAL("abcdefghijklmnopqrstuvwxyz");

		{
			StringType str;
			str = sv;  // force call to 'operator='
			VERIFY(str == LITERAL("abcdefghijklmnopqrstuvwxyz"));
		}
	}

	// test eastl::erase
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		eastl::erase(str, LITERAL('a'));
		eastl::erase(str, LITERAL('f'));
		eastl::erase(str, LITERAL('l'));
		eastl::erase(str, LITERAL('w'));
		eastl::erase(str, LITERAL('y'));
		VERIFY(str == LITERAL("bcdeghijkmnopqrstuvxz"));
	}

	// test eastl::erase_if
	{
		StringType str(LITERAL("abcdefghijklmnopqrstuvwxyz"));
		eastl::erase_if(str, [](auto c) { return c == LITERAL('a') || c == LITERAL('v'); });
		VERIFY(str == LITERAL("bcdefghijklmnopqrstuwxyz"));
	}

	// template<> struct hash<eastl::string>;
	// template<> struct hash<eastl::wstring>;
	// template<> struct hash<eastl::u16string>;
	// template<> struct hash<eastl::u32string>;
	{
		// NOTE(rparolin): This is required because the string tests inject custom allocators to assist in debugging.
		// These custom string types require their own hashing specializations which we emulate by constructing a custom
		// hashing functor that defers to the eastl::basic_string<CharT> hash implementation; effectively ignoring the
		// custom allocator.
	    auto LocalHash = [](auto s) -> size_t {
		    using UserStringType = decltype(s);
		    using TargetType = eastl::basic_string<typename UserStringType::value_type>;

		    TargetType t(s.data());
		    return eastl::hash<TargetType>{}(t);
	    };

	    StringType sw1(LITERAL("Hello, World"));
		StringType sw2(LITERAL("Hello, World"), 5);
		StringType sw3(LITERAL("Hello"));

		VERIFY(LocalHash(sw1) != LocalHash(sw2));
		VERIFY(LocalHash(sw2) == LocalHash(sw3));
	}

	return nErrorCount;
}

// Required to prevent manual undef of macros when 'TestString.inl' preprocessed at the top of the unit test cpp file.
#undef TEST_STRING_NAME
#undef LITERAL