Roberto Parolin 6 years ago
parent
commit
4828af4c23

+ 1 - 1
include/EAStdC/EAProcess.h

@@ -29,7 +29,7 @@ namespace EA
 		#if defined(EA_PLATFORM_WINDOWS) && EA_WINAPI_FAMILY_PARTITION(EA_WINAPI_PARTITION_DESKTOP)
 			const int kMaxPathLength      = _MAX_PATH;
 			const int kMaxDirectoryLength = _MAX_PATH;
-		#elif defined(EA_PLATFORM_XBOXONE)
+		#elif defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
 			const int kMaxPathLength      = 260;
 			const int kMaxDirectoryLength = 260;
 		#elif defined(EA_PLATFORM_SONY)

+ 2 - 2
include/EAStdC/internal/Config.h

@@ -32,8 +32,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef EASTDC_VERSION
-	#define EASTDC_VERSION   "1.26.06"
-	#define EASTDC_VERSION_N  12606
+	#define EASTDC_VERSION   "1.26.07"
+	#define EASTDC_VERSION_N  12607
 #endif
 
 

+ 1 - 1
source/EAStopwatch.cpp

@@ -194,7 +194,7 @@ void EAStdCStopwatchSetup()
 			// Stopwatch Frequency
 			mnStopwatchFrequency = mnCPUFrequency;
 
-		#elif defined(EA_PLATFORM_XBOXONE)
+		#elif defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
 			// Microsoft has stated (https://forums.xboxlive.com/AnswerPage.aspx?qid=c3fcdad5-f3e4-46d9-85f9-d337506f0d6b&tgt=1) that  
 			// QueryPerformanceCounter / QueryPerformanceFrequency map to rdtsc and they are stable throughout the life of the process.
 			// Thus we can use QueryPerformanceFrequency to portable tell the CPU frequency for our usage of rdtsc.

+ 29 - 0
test/include/EAStdCTest/EAStdCTest.h

@@ -193,6 +193,35 @@ extern volatile int gWriteToEnsureFunctionCalled;
 
 #endif
 
+inline double DoubleAbsoluteDifference(double x1, double x2)
+{
+	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
+}
+
+inline bool DoubleEqual(double x1, double x2)
+{
+	if(x1 < 1e-15)
+		return (x2 < 1e-15);
+	else if(x2 < 1e-15)
+		return (x1 < 1e-15);
+	else
+		return DoubleAbsoluteDifference((x1 - x2) / x1, 1e-15) < 1e-13;
+}
+
+inline double FloatAbsoluteDifference(float x1, float x2)
+{
+	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
+}
+
+inline bool FloatEqual(float x1, float x2)
+{
+	if(x1 < 1e-7f)
+		return (x2 < 1e-7f);
+	else if(x2 < 1e-7f)
+		return (x1 < 1e-7f);
+	else
+		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
+}
 
 #endif // Header include guard
 

+ 0 - 1
test/source/EAStdCTest.cpp

@@ -158,7 +158,6 @@ void operator delete(void* p, char const*, int, unsigned, char const*, int)
 	size_t sceLibcHeapSize = 128*1024*1024;
 #endif
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // EAMain
 //

+ 6 - 8
test/source/TestDateTime.cpp

@@ -16,16 +16,14 @@
 
 
 #if defined(EA_PLATFORM_MICROSOFT)
-	#ifdef _MSC_VER
-		#pragma warning(push, 0)
-		#if !(defined(EA_PLATFORM_WINDOWS) && !EA_WINAPI_FAMILY_PARTITION(EA_WINAPI_PARTITION_DESKTOP))
-			#include <winsock2.h> // for timeval
-		#endif
-		#include <Windows.h>
-		#pragma warning(pop)
+	EA_DISABLE_ALL_VC_WARNINGS()
+	#if defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
+		#include <winsock2.h> // for timeval
 	#else
-		#include <Windows.h>
+		#include <winsock.h> // for timeval
 	#endif
+	#include <Windows.h>
+	EA_RESTORE_ALL_VC_WARNINGS()
 
 	bool GetLocaleInfoHelper(LCTYPE lcType, char* lcData, int cchData)
 	{

+ 0 - 15
test/source/TestInt128.cpp

@@ -22,21 +22,6 @@
 	#pragma warning(pop)
 #endif
 
-static inline double FloatAbsoluteDifference(float x1, float x2)
-{
-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
-}
-
-static inline bool FloatEqual(float x1, float x2)
-{
-	if(x1 < 1e-7f)
-		return (x2 < 1e-7f);
-	else if(x2 < 1e-7f)
-		return (x1 < 1e-7f);
-	else
-		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
-}
-
 static bool CompareSelfTestResult(const char* p1, const char* p2)
 {
 	return strcmp(p1, p2) == 0;

+ 0 - 34
test/source/TestScanf.cpp

@@ -122,40 +122,6 @@ static int TestCRTVsscanf(const char32_t* pBuffer, const char32_t* pFormat, ...)
 	return n;
 }
 
-
-
-static inline double DoubleAbsoluteDifference(double x1, double x2)
-{
-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
-}
-
-static inline bool DoubleEqual(double x1, double x2)
-{
-	if(x1 < 1e-15)
-		return (x2 < 1e-15);
-	else if(x2 < 1e-15)
-		return (x1 < 1e-15);
-	else
-		return DoubleAbsoluteDifference((x1 - x2) / x1, 1e-15) < 1e-13;
-}
-
-static inline double FloatAbsoluteDifference(float x1, float x2)
-{
-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
-}
-
-static inline bool FloatEqual(float x1, float x2)
-{
-	if(x1 < 1e-7f)
-		return (x2 < 1e-7f);
-	else if(x2 < 1e-7f)
-		return (x1 < 1e-7f);
-	else
-		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
-}
-
-
-
 ///////////////////////////////////////////////////////////////////////////////
 // TestScanfLimits
 //

+ 68 - 68
test/source/TestString.cpp

@@ -25,7 +25,7 @@
 #endif
 
 
-static inline bool DoubleEqual(double x1, double x2)
+static inline bool TestString_DoubleEqual(double x1, double x2)
 {
 	double difference = fabs(x1 - x2);
 	double relative   = fabs(difference / x1);
@@ -34,7 +34,7 @@ static inline bool DoubleEqual(double x1, double x2)
 		return true;
 	else
 	{
-		EA::UnitTest::Report("DoubleEqual Error: %f, %f\n", x1, x2);
+		EA::UnitTest::Report("TestString_DoubleEqual Error: %f, %f\n", x1, x2);
 		return false;
 	}
 }
@@ -2304,49 +2304,49 @@ static int TestStrtod()
 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
 
 		p = "-111.111";
-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
 
 		p = "111e111";
-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
 
 		p = "-111e-111";
-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
 
 		p = "137";
-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
 
 		p = "999999";
-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
 
 		p = "123.456";
-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
 
 		p = "123232111.000123";
-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = "-888111.000123";
-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = "-123.456";
-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
 
 		p = "+999999";
-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
 
 		p = "+999999e2";
-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
 
 		p = "-234.567E-3";
-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
 
 		p = "321654.987e11";
-		EATEST_VERIFY(DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
 
 		p = "-321654.987E0";
-		EATEST_VERIFY(DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
 
 		p = "+321654.987e-0";
-		EATEST_VERIFY(DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
 	}
 	{
 		const char16_t* p;
@@ -2360,49 +2360,49 @@ static int TestStrtod()
 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
 
 		p = EA_CHAR16("-111.111");
-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("111e111");
-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("-111e-111");
-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("137");
-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("999999");
-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("123.456");
-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("123232111.000123");
-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("-888111.000123");
-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("-123.456");
-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("+999999");
-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("+999999e2");
-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("-234.567E-3");
-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("321654.987e11");
-		EATEST_VERIFY(DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("-321654.987E0");
-		EATEST_VERIFY(DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR16("+321654.987e-0");
-		EATEST_VERIFY(DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
 	}
 	{
 		const char32_t* p;
@@ -2416,49 +2416,49 @@ static int TestStrtod()
 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
 
 		p = EA_CHAR32("-111.111");
-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("111e111");
-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("-111e-111");
-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("137");
-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("999999");
-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("123.456");
-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("123232111.000123");
-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("-888111.000123");
-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("-123.456");
-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("+999999");
-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("+999999e2");
-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("-234.567E-3");
-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("323254.987e11");
-		EATEST_VERIFY(DoubleEqual(323254.987e11, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(323254.987e11, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("-323254.987E0");
-		EATEST_VERIFY(DoubleEqual(-323254.987E0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-323254.987E0, StrtodEnglish(p, &pEnd)));
 
 		p = EA_CHAR32("+323254.987e-0");
-		EATEST_VERIFY(DoubleEqual(+323254.987e-0, StrtodEnglish(p, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(+323254.987e-0, StrtodEnglish(p, &pEnd)));
 	}
 
 
@@ -2468,35 +2468,35 @@ static int TestStrtod()
 	{
 		char  sn18[] = "-111.111";
 		char* pEnd = NULL;
-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
 
 		char sn28[] = "111e111";
-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
 
 		char sn38[] = "-111e-111";
-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
 	}
 	{
 		char16_t  sn18[16]; Strlcpy(sn18, EA_CHAR16("-111.111"), EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
 		char16_t* pEnd = NULL;
-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
 
 		char16_t sn28[16]; Strlcpy(sn28, EA_CHAR16("111e111"), EAArrayCount(sn28)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
 
 		char16_t sn38[16]; Strlcpy(sn38, EA_CHAR16("-111e-111"), EAArrayCount(sn38)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
 	}
 	{
 		char32_t  sn18[32]; Strlcpy(sn18, EA_CHAR32("-111.111"), EAArrayCount(sn18)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
 		char32_t* pEnd = NULL;
-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
 
 		char32_t sn28[32]; Strlcpy(sn28, EA_CHAR32("111e111"), EAArrayCount(sn28)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
 
 		char32_t sn38[32]; Strlcpy(sn38, EA_CHAR32("-111e-111"), EAArrayCount(sn38)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
 	}
 
 	return nErrorCount;
@@ -3120,28 +3120,28 @@ static int TestAtof()
 
 		{
 			double d = Atof(kStrMax);
-			EATEST_VERIFY(DoubleEqual(d, kValMax));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
 
 			d = Atof(kStrMin);
-			EATEST_VERIFY(DoubleEqual(d, kValMin));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
 		}
 		{
 			char16_t sn18[32]; Strlcpy(sn18, kStrMax, EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
 			double  d = Atof(sn18);
-			EATEST_VERIFY(DoubleEqual(d, kValMax));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
 
 			char16_t sn28[32]; Strlcpy(sn28, kStrMin, EAArrayCount(sn28));
 			d = Atof(sn28);
-			EATEST_VERIFY(DoubleEqual(d, kValMin));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
 		}
 		{
 			char32_t sn18[32]; Strlcpy(sn18, kStrMax, EAArrayCount(sn18));
 			double d = Atof(sn18);
-			EATEST_VERIFY(DoubleEqual(d, kValMax));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
 
 			char32_t sn28[32]; Strlcpy(sn28, kStrMin, EAArrayCount(sn28));
 			d = Atof(sn28);
-			EATEST_VERIFY(DoubleEqual(d, kValMin));
+			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
 		}
 	}
 
@@ -3159,23 +3159,23 @@ static int TestAtof()
 		const double   kValMax =  1.7976931348622e+307;
 
 		{
-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(kStrMin)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(kStrMin)));
 
-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(kStrMax)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(kStrMax)));
 		}
 		{
 			char16_t sn18[32]; Strlcpy(sn18, kStrMin, EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(sn18)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(sn18)));
 
 			char16_t sn28[32]; Strlcpy(sn28, kStrMax, EAArrayCount(sn28));
-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(sn28)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(sn28)));
 		}
 		{
 			char32_t sn18[32]; Strlcpy(sn18, kStrMin, EAArrayCount(sn18));
-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(sn18)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(sn18)));
 
 			char32_t sn28[32]; Strlcpy(sn28, kStrMax, EAArrayCount(sn28));
-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(sn28)));
+			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(sn28)));
 		}
 	}
 

+ 518 - 0


@@ -0,0 +1,518 @@
+diff --git a/include/EAStdC/EAProcess.h b/include/EAStdC/EAProcess.h
+index 8682f15..0b69020 100644
+--- a/include/EAStdC/EAProcess.h
++++ b/include/EAStdC/EAProcess.h
+@@ -29,7 +29,7 @@ namespace EA
+ 		#if defined(EA_PLATFORM_WINDOWS) && EA_WINAPI_FAMILY_PARTITION(EA_WINAPI_PARTITION_DESKTOP)
+ 			const int kMaxPathLength      = _MAX_PATH;
+ 			const int kMaxDirectoryLength = _MAX_PATH;
+-		#elif defined(EA_PLATFORM_XBOXONE)
++		#elif defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
+ 			const int kMaxPathLength      = 260;
+ 			const int kMaxDirectoryLength = 260;
+ 		#elif defined(EA_PLATFORM_SONY)
+diff --git a/include/EAStdC/internal/Config.h b/include/EAStdC/internal/Config.h
+index 5c80cf2..08f0a29 100644
+--- a/include/EAStdC/internal/Config.h
++++ b/include/EAStdC/internal/Config.h
+@@ -32,8 +32,8 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ 
+ #ifndef EASTDC_VERSION
+-	#define EASTDC_VERSION   "1.26.06"
+-	#define EASTDC_VERSION_N  12606
++	#define EASTDC_VERSION   "1.26.07"
++	#define EASTDC_VERSION_N  12607
+ #endif
+ 
+ 
+diff --git a/source/EAStopwatch.cpp b/source/EAStopwatch.cpp
+index 4410625..9cded62 100644
+--- a/source/EAStopwatch.cpp
++++ b/source/EAStopwatch.cpp
+@@ -194,7 +194,7 @@ void EAStdCStopwatchSetup()
+ 			// Stopwatch Frequency
+ 			mnStopwatchFrequency = mnCPUFrequency;
+ 
+-		#elif defined(EA_PLATFORM_XBOXONE)
++		#elif defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
+ 			// Microsoft has stated (https://forums.xboxlive.com/AnswerPage.aspx?qid=c3fcdad5-f3e4-46d9-85f9-d337506f0d6b&tgt=1) that  
+ 			// QueryPerformanceCounter / QueryPerformanceFrequency map to rdtsc and they are stable throughout the life of the process.
+ 			// Thus we can use QueryPerformanceFrequency to portable tell the CPU frequency for our usage of rdtsc.
+diff --git a/test/include/EAStdCTest/EAStdCTest.h b/test/include/EAStdCTest/EAStdCTest.h
+index 462c2cc..59c3787 100644
+--- a/test/include/EAStdCTest/EAStdCTest.h
++++ b/test/include/EAStdCTest/EAStdCTest.h
+@@ -193,6 +193,35 @@ extern volatile int gWriteToEnsureFunctionCalled;
+ 
+ #endif
+ 
++inline double DoubleAbsoluteDifference(double x1, double x2)
++{
++	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
++}
++
++inline bool DoubleEqual(double x1, double x2)
++{
++	if(x1 < 1e-15)
++		return (x2 < 1e-15);
++	else if(x2 < 1e-15)
++		return (x1 < 1e-15);
++	else
++		return DoubleAbsoluteDifference((x1 - x2) / x1, 1e-15) < 1e-13;
++}
++
++inline double FloatAbsoluteDifference(float x1, float x2)
++{
++	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
++}
++
++inline bool FloatEqual(float x1, float x2)
++{
++	if(x1 < 1e-7f)
++		return (x2 < 1e-7f);
++	else if(x2 < 1e-7f)
++		return (x1 < 1e-7f);
++	else
++		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
++}
+ 
+ #endif // Header include guard
+ 
+diff --git a/test/source/EAStdCTest.cpp b/test/source/EAStdCTest.cpp
+index f902be1..27ad6ba 100644
+--- a/test/source/EAStdCTest.cpp
++++ b/test/source/EAStdCTest.cpp
+@@ -158,7 +158,6 @@ void operator delete(void* p, char const*, int, unsigned, char const*, int)
+ 	size_t sceLibcHeapSize = 128*1024*1024;
+ #endif
+ 
+-
+ ///////////////////////////////////////////////////////////////////////////////
+ // EAMain
+ //
+diff --git a/test/source/TestDateTime.cpp b/test/source/TestDateTime.cpp
+index db4096a..8a084ff 100644
+--- a/test/source/TestDateTime.cpp
++++ b/test/source/TestDateTime.cpp
+@@ -16,16 +16,14 @@
+ 
+ 
+ #if defined(EA_PLATFORM_MICROSOFT)
+-	#ifdef _MSC_VER
+-		#pragma warning(push, 0)
+-		#if !(defined(EA_PLATFORM_WINDOWS) && !EA_WINAPI_FAMILY_PARTITION(EA_WINAPI_PARTITION_DESKTOP))
+-			#include <winsock2.h> // for timeval
+-		#endif
+-		#include <Windows.h>
+-		#pragma warning(pop)
++	EA_DISABLE_ALL_VC_WARNINGS()
++	#if defined(EA_PLATFORM_XBOXONE) || defined(CS_UNDEFINED_STRING)
++		#include <winsock2.h> // for timeval
+ 	#else
+-		#include <Windows.h>
++		#include <winsock.h> // for timeval
+ 	#endif
++	#include <Windows.h>
++	EA_RESTORE_ALL_VC_WARNINGS()
+ 
+ 	bool GetLocaleInfoHelper(LCTYPE lcType, char* lcData, int cchData)
+ 	{
+diff --git a/test/source/TestInt128.cpp b/test/source/TestInt128.cpp
+index 066ad90..e5aece4 100644
+--- a/test/source/TestInt128.cpp
++++ b/test/source/TestInt128.cpp
+@@ -22,21 +22,6 @@
+ 	#pragma warning(pop)
+ #endif
+ 
+-static inline double FloatAbsoluteDifference(float x1, float x2)
+-{
+-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
+-}
+-
+-static inline bool FloatEqual(float x1, float x2)
+-{
+-	if(x1 < 1e-7f)
+-		return (x2 < 1e-7f);
+-	else if(x2 < 1e-7f)
+-		return (x1 < 1e-7f);
+-	else
+-		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
+-}
+-
+ static bool CompareSelfTestResult(const char* p1, const char* p2)
+ {
+ 	return strcmp(p1, p2) == 0;
+diff --git a/test/source/TestScanf.cpp b/test/source/TestScanf.cpp
+index 652742a..311461b 100644
+--- a/test/source/TestScanf.cpp
++++ b/test/source/TestScanf.cpp
+@@ -122,40 +122,6 @@ static int TestCRTVsscanf(const char32_t* pBuffer, const char32_t* pFormat, ...)
+ 	return n;
+ }
+ 
+-
+-
+-static inline double DoubleAbsoluteDifference(double x1, double x2)
+-{
+-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
+-}
+-
+-static inline bool DoubleEqual(double x1, double x2)
+-{
+-	if(x1 < 1e-15)
+-		return (x2 < 1e-15);
+-	else if(x2 < 1e-15)
+-		return (x1 < 1e-15);
+-	else
+-		return DoubleAbsoluteDifference((x1 - x2) / x1, 1e-15) < 1e-13;
+-}
+-
+-static inline double FloatAbsoluteDifference(float x1, float x2)
+-{
+-	return (x1 < x2) ? (x2 - x1) : (x1 - x2);
+-}
+-
+-static inline bool FloatEqual(float x1, float x2)
+-{
+-	if(x1 < 1e-7f)
+-		return (x2 < 1e-7f);
+-	else if(x2 < 1e-7f)
+-		return (x1 < 1e-7f);
+-	else
+-		return FloatAbsoluteDifference((x1 - x2) / x1, 1e-7f) < 1e-5f;
+-}
+-
+-
+-
+ ///////////////////////////////////////////////////////////////////////////////
+ // TestScanfLimits
+ //
+diff --git a/test/source/TestString.cpp b/test/source/TestString.cpp
+index 2f4fcde..4f26a2f 100644
+--- a/test/source/TestString.cpp
++++ b/test/source/TestString.cpp
+@@ -25,7 +25,7 @@
+ #endif
+ 
+ 
+-static inline bool DoubleEqual(double x1, double x2)
++static inline bool TestString_DoubleEqual(double x1, double x2)
+ {
+ 	double difference = fabs(x1 - x2);
+ 	double relative   = fabs(difference / x1);
+@@ -34,7 +34,7 @@ static inline bool DoubleEqual(double x1, double x2)
+ 		return true;
+ 	else
+ 	{
+-		EA::UnitTest::Report("DoubleEqual Error: %f, %f\n", x1, x2);
++		EA::UnitTest::Report("TestString_DoubleEqual Error: %f, %f\n", x1, x2);
+ 		return false;
+ 	}
+ }
+@@ -2304,49 +2304,49 @@ static int TestStrtod()
+ 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
+ 
+ 		p = "-111.111";
+-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "111e111";
+-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "-111e-111";
+-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "137";
+-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "999999";
+-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "123.456";
+-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "123232111.000123";
+-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "-888111.000123";
+-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "-123.456";
+-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "+999999";
+-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "+999999e2";
+-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "-234.567E-3";
+-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "321654.987e11";
+-		EATEST_VERIFY(DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "-321654.987E0";
+-		EATEST_VERIFY(DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = "+321654.987e-0";
+-		EATEST_VERIFY(DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
+ 	}
+ 	{
+ 		const char16_t* p;
+@@ -2360,49 +2360,49 @@ static int TestStrtod()
+ 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
+ 
+ 		p = EA_CHAR16("-111.111");
+-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("111e111");
+-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("-111e-111");
+-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("137");
+-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("999999");
+-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("123.456");
+-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("123232111.000123");
+-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("-888111.000123");
+-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("-123.456");
+-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("+999999");
+-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("+999999e2");
+-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("-234.567E-3");
+-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("321654.987e11");
+-		EATEST_VERIFY(DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(321654.987e11, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("-321654.987E0");
+-		EATEST_VERIFY(DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-321654.987E0, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR16("+321654.987e-0");
+-		EATEST_VERIFY(DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+321654.987e-0, StrtodEnglish(p, &pEnd)));
+ 	}
+ 	{
+ 		const char32_t* p;
+@@ -2416,49 +2416,49 @@ static int TestStrtod()
+ 		//EATEST_VERIFY(0 == StrtodEnglish(p, &pEnd));
+ 
+ 		p = EA_CHAR32("-111.111");
+-		EATEST_VERIFY(DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("111e111");
+-		EATEST_VERIFY(DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("-111e-111");
+-		EATEST_VERIFY(DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("137");
+-		EATEST_VERIFY(DoubleEqual(137, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(137, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("999999");
+-		EATEST_VERIFY(DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("123.456");
+-		EATEST_VERIFY(DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("123232111.000123");
+-		EATEST_VERIFY(DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(123232111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("-888111.000123");
+-		EATEST_VERIFY(DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-888111.000123, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("-123.456");
+-		EATEST_VERIFY(DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-123.456, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("+999999");
+-		EATEST_VERIFY(DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("+999999e2");
+-		EATEST_VERIFY(DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+999999e2, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("-234.567E-3");
+-		EATEST_VERIFY(DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-234.567E-3, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("323254.987e11");
+-		EATEST_VERIFY(DoubleEqual(323254.987e11, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(323254.987e11, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("-323254.987E0");
+-		EATEST_VERIFY(DoubleEqual(-323254.987E0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-323254.987E0, StrtodEnglish(p, &pEnd)));
+ 
+ 		p = EA_CHAR32("+323254.987e-0");
+-		EATEST_VERIFY(DoubleEqual(+323254.987e-0, StrtodEnglish(p, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(+323254.987e-0, StrtodEnglish(p, &pEnd)));
+ 	}
+ 
+ 
+@@ -2468,35 +2468,35 @@ static int TestStrtod()
+ 	{
+ 		char  sn18[] = "-111.111";
+ 		char* pEnd = NULL;
+-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+ 
+ 		char sn28[] = "111e111";
+-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+ 
+ 		char sn38[] = "-111e-111";
+-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+ 	}
+ 	{
+ 		char16_t  sn18[16]; Strlcpy(sn18, EA_CHAR16("-111.111"), EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
+ 		char16_t* pEnd = NULL;
+-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+ 
+ 		char16_t sn28[16]; Strlcpy(sn28, EA_CHAR16("111e111"), EAArrayCount(sn28)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
+-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+ 
+ 		char16_t sn38[16]; Strlcpy(sn38, EA_CHAR16("-111e-111"), EAArrayCount(sn38)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
+-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+ 	}
+ 	{
+ 		char32_t  sn18[32]; Strlcpy(sn18, EA_CHAR32("-111.111"), EAArrayCount(sn18)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
+ 		char32_t* pEnd = NULL;
+-		EATEST_VERIFY(DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111.111, Strtod(sn18, &pEnd)));
+ 
+ 		char32_t sn28[32]; Strlcpy(sn28, EA_CHAR32("111e111"), EAArrayCount(sn28)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
+-		EATEST_VERIFY(DoubleEqual(111e111, Strtod(sn28, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(111e111, Strtod(sn28, &pEnd)));
+ 
+ 		char32_t sn38[32]; Strlcpy(sn38, EA_CHAR32("-111e-111"), EAArrayCount(sn38)); // Can't do char32_t variable[64] = EA_CHAR32(...) because some compilers don't support 32 bit string literals.
+-		EATEST_VERIFY(DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
++		EATEST_VERIFY(TestString_DoubleEqual(-111e-111, Strtod(sn38, &pEnd)));
+ 	}
+ 
+ 	return nErrorCount;
+@@ -3120,28 +3120,28 @@ static int TestAtof()
+ 
+ 		{
+ 			double d = Atof(kStrMax);
+-			EATEST_VERIFY(DoubleEqual(d, kValMax));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
+ 
+ 			d = Atof(kStrMin);
+-			EATEST_VERIFY(DoubleEqual(d, kValMin));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
+ 		}
+ 		{
+ 			char16_t sn18[32]; Strlcpy(sn18, kStrMax, EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
+ 			double  d = Atof(sn18);
+-			EATEST_VERIFY(DoubleEqual(d, kValMax));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
+ 
+ 			char16_t sn28[32]; Strlcpy(sn28, kStrMin, EAArrayCount(sn28));
+ 			d = Atof(sn28);
+-			EATEST_VERIFY(DoubleEqual(d, kValMin));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
+ 		}
+ 		{
+ 			char32_t sn18[32]; Strlcpy(sn18, kStrMax, EAArrayCount(sn18));
+ 			double d = Atof(sn18);
+-			EATEST_VERIFY(DoubleEqual(d, kValMax));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMax));
+ 
+ 			char32_t sn28[32]; Strlcpy(sn28, kStrMin, EAArrayCount(sn28));
+ 			d = Atof(sn28);
+-			EATEST_VERIFY(DoubleEqual(d, kValMin));
++			EATEST_VERIFY(TestString_DoubleEqual(d, kValMin));
+ 		}
+ 	}
+ 
+@@ -3159,23 +3159,23 @@ static int TestAtof()
+ 		const double   kValMax =  1.7976931348622e+307;
+ 
+ 		{
+-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(kStrMin)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(kStrMin)));
+ 
+-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(kStrMax)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(kStrMax)));
+ 		}
+ 		{
+ 			char16_t sn18[32]; Strlcpy(sn18, kStrMin, EAArrayCount(sn18)); // Can't do char16_t variable[64] = EA_CHAR16(...) because some compilers don't support 16 bit string literals.
+-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(sn18)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(sn18)));
+ 
+ 			char16_t sn28[32]; Strlcpy(sn28, kStrMax, EAArrayCount(sn28));
+-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(sn28)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(sn28)));
+ 		}
+ 		{
+ 			char32_t sn18[32]; Strlcpy(sn18, kStrMin, EAArrayCount(sn18));
+-			EATEST_VERIFY(DoubleEqual(kValMin, AtofEnglish(sn18)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMin, AtofEnglish(sn18)));
+ 
+ 			char32_t sn28[32]; Strlcpy(sn28, kStrMax, EAArrayCount(sn28));
+-			EATEST_VERIFY(DoubleEqual(kValMax, AtofEnglish(sn28)));
++			EATEST_VERIFY(TestString_DoubleEqual(kValMax, AtofEnglish(sn28)));
+ 		}
+ 	}
+