diff options
Diffstat (limited to 'test/source/TestString.cpp')
| -rw-r--r-- | test/source/TestString.cpp | 142 |
1 files changed, 142 insertions, 0 deletions
diff --git a/test/source/TestString.cpp b/test/source/TestString.cpp new file mode 100644 index 0000000..1bd06e7 --- /dev/null +++ b/test/source/TestString.cpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////// +// Copyright (c) Electronic Arts Inc. All rights reserved. +///////////////////////////////////////////////////////////////////////////// + +#include "EASTLTest.h" +#include <EABase/eabase.h> +#include <EAStdC/EAMemory.h> +#include <EAStdC/EAString.h> +#include <EASTL/string.h> +#include <EASTL/algorithm.h> +#include <EASTL/allocator_malloc.h> + +using namespace eastl; + +// Verify char8_t support is present if the test build requested it. +#if defined(EASTL_EXPECT_CHAR8T_SUPPORT) && !EA_CHAR8_UNIQUE +static_assert(false, "Building with char8_t tests enabled, but EA_CHAR8_UNIQUE evaluates to false."); +#endif + + +// inject string literal string conversion macros into the unit tests +#define TEST_STRING_NAME TestBasicString +#define LITERAL(x) x +#include "TestString.inl" + +#define TEST_STRING_NAME TestBasicStringW +#define LITERAL(x) EA_WCHAR(x) +#include "TestString.inl" + +#define TEST_STRING_NAME TestBasicString8 +#define LITERAL(x) EA_CHAR8(x) +#include "TestString.inl" + +#define TEST_STRING_NAME TestBasicString16 +#define LITERAL(x) EA_CHAR16(x) +#include "TestString.inl" + +#define TEST_STRING_NAME TestBasicString32 +#define LITERAL(x) EA_CHAR32(x) +#include "TestString.inl" + +int TestString() +{ + int nErrorCount = 0; + + nErrorCount += TestBasicString<eastl::basic_string<char, StompDetectAllocator>>(); + nErrorCount += TestBasicString<eastl::string>(); + + nErrorCount += TestBasicStringW<eastl::basic_string<wchar_t, StompDetectAllocator>>(); + nErrorCount += TestBasicStringW<eastl::wstring>(); + +#if defined(EA_CHAR8_UNIQUE) && EA_CHAR8_UNIQUE + nErrorCount += TestBasicString8<eastl::basic_string<char8_t, StompDetectAllocator>>(); + nErrorCount += TestBasicString8<eastl::u8string>(); +#endif + + nErrorCount += TestBasicString16<eastl::basic_string<char16_t, StompDetectAllocator>>(); + nErrorCount += TestBasicString16<eastl::u16string>(); + +#if defined(EA_CHAR32_NATIVE) && EA_CHAR32_NATIVE + nErrorCount += TestBasicString32<eastl::basic_string<char32_t, StompDetectAllocator>>(); + nErrorCount += TestBasicString32<eastl::u32string>(); +#endif + + // Check for memory leaks by using the 'CountingAllocator' to ensure no active allocation after tests have completed. + CountingAllocator::resetCount(); + nErrorCount += TestBasicString<eastl::basic_string<char, CountingAllocator>>(); + VERIFY(CountingAllocator::getActiveAllocationCount() == 0); + + nErrorCount += TestBasicStringW<eastl::basic_string<wchar_t, CountingAllocator>>(); + VERIFY(CountingAllocator::getActiveAllocationCount() == 0); + +#if defined(EA_CHAR8_UNIQUE) && EA_CHAR8_UNIQUE + nErrorCount += TestBasicString8<eastl::basic_string<char8_t, CountingAllocator>>(); + VERIFY(CountingAllocator::getActiveAllocationCount() == 0); +#endif + + nErrorCount += TestBasicString16<eastl::basic_string<char16_t, CountingAllocator>>(); + VERIFY(CountingAllocator::getActiveAllocationCount() == 0); + +#if defined(EA_CHAR32_NATIVE) && EA_CHAR32_NATIVE + nErrorCount += TestBasicString32<eastl::basic_string<char32_t, CountingAllocator>>(); + VERIFY(CountingAllocator::getActiveAllocationCount() == 0); +#endif + + // to_string + { + VERIFY(eastl::to_string(42) == "42"); + VERIFY(eastl::to_string(42l) == "42"); + VERIFY(eastl::to_string(42ll) == "42"); + VERIFY(eastl::to_string(42u) == "42"); + VERIFY(eastl::to_string(42ul) == "42"); + VERIFY(eastl::to_string(42ull) == "42"); + VERIFY(eastl::to_string(42.f) == "42.000000"); + VERIFY(eastl::to_string(42.0) == "42.000000"); + #if !defined(EA_COMPILER_GNUC) && !defined(EA_PLATFORM_MINGW) + // todo: long double sprintf functionality is unrealiable on unix-gcc, requires further debugging. + VERIFY(eastl::to_string(42.0l) == "42.000000"); + #endif + } + + // to_wstring + { + VERIFY(eastl::to_wstring(42) == L"42"); + VERIFY(eastl::to_wstring(42l) == L"42"); + VERIFY(eastl::to_wstring(42ll) == L"42"); + VERIFY(eastl::to_wstring(42u) == L"42"); + VERIFY(eastl::to_wstring(42ul) == L"42"); + VERIFY(eastl::to_wstring(42ull) == L"42"); + VERIFY(eastl::to_wstring(42.f) == L"42.000000"); + VERIFY(eastl::to_wstring(42.0) == L"42.000000"); + #if !defined(EA_COMPILER_GNUC) && !defined(EA_PLATFORM_MINGW) + // todo: long double sprintf functionality is unrealiable on unix-gcc, requires further debugging. + VERIFY(eastl::to_wstring(42.0l) == L"42.000000"); + #endif + } + + #if EASTL_USER_LITERALS_ENABLED + { + VERIFY("cplusplus"s == "cplusplus"); + VERIFY(L"cplusplus"s == L"cplusplus"); + VERIFY(u"cplusplus"s == u"cplusplus"); + VERIFY(U"cplusplus"s == U"cplusplus"); + VERIFY(u8"cplusplus"s == u8"cplusplus"); + } + #endif + + + { + // CustomAllocator has no data members which reduces the size of an eastl::basic_string via the empty base class optimization. + using EboString = eastl::basic_string<char, CustomAllocator>; + + // this must match the eastl::basic_string heap memory layout struct which is a pointer and 2 eastl_size_t. + const int expectedSize = sizeof(EboString::pointer) + (2 * sizeof(EboString::size_type)); + + static_assert(sizeof(EboString) == expectedSize, "unexpected layout size of basic_string"); + } + + return nErrorCount; +} + + |