Merging r5975 through r6036 from trunk to ogl-es branch.

GLES drivers adapted, but only did make compile-tests.


git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/branches/ogl-es@6038 dfc29bdd-3216-0410-991c-e03cc46cb475

1 files changed, 415 insertions, 0 deletions

diff --git a/tests/irrString.cpp b/tests/irrString.cpp
new file mode 100644
index 0000000..a5298ff
--- /dev/null
+++ b/tests/irrString.cpp
@@ -0,0 +1,415 @@
+// Copyright (C) 2008-2012 Colin MacDonald

+// No rights reserved: this software is in the public domain.

+

+#include "testUtils.h"

+#include <irrlicht.h>

+

+using namespace irr;

+using namespace core;

+

+static bool testSelfAssignment()

+{

+	core::stringw myString(L"foo");

+	myString = myString;

+	return myString == core::stringw(L"foo");

+}

+

+static bool testSplit()

+{

+	logTestString("Test stringw::split()\n");

+	core::stringw teststring(L"[b]this [/b] is a [color=0xff000000]test[/color].");

+	core::list<core::stringw> parts1;

+	teststring.split<core::list<core::stringw> >(parts1, L"[");

+	core::array<core::stringw> parts2;

+	teststring.split<core::array<core::stringw> >(parts2, L"[", 1, false, true);

+	return (parts1.size()==4) && (parts2.size()==9);

+}

+

+static bool testFastAlloc()

+{

+	core::string<wchar_t, core::irrAllocatorFast<wchar_t> > FastString(L"abc");

+	core::string<wchar_t, core::irrAllocatorFast<wchar_t> > FastStringLong(L"longer");

+

+	FastString  = L"test";

+

+	// cause a reallocation

+	FastString = FastStringLong;

+

+	// this test should either not compile or crash when the allocaters are messed up

+	return true;

+}

+

+static bool testReplace()

+{

+	// test string getting longer

+	core::stringw str = L"no";

+	str.replace(L"no", L"yes");

+	if ( str != L"yes" )

+		return false;

+	str = L"nonono";

+	str.replace(L"no", L"yes");

+	if ( str != L"yesyesyes" )

+		return false;

+	str = L"nomaybenomaybeno";

+	str.replace(L"no", L"yes");

+	if ( str != L"yesmaybeyesmaybeyes" )

+		return false;

+

+	// test string staying same length

+	str = L"one";

+	str.replace(L"one", L"two");

+	if ( str != L"two" )

+		return false;

+	str = L"oneone";

+	str.replace(L"one", L"two");

+	if ( str != L"twotwo" )

+		return false;

+

+	// test string getting shorter

+	str = L"yes";

+	str.replace(L"yes", L"no");

+	if ( str != L"no" )

+		return false;

+

+	str = L"yesyes";

+	str.replace(L"yes", L"no");

+	if ( str != L"nono" )

+		return false;

+

+	// remove string-parts completely

+	str = L"killme";

+	str.replace(L"killme", L"");

+	if ( str != L"" )

+		return false;

+

+	str = L"killmenow";

+	str.replace(L"killme", L"");

+	if ( str != L"now" )

+		return false;

+

+	str = L"nowkillme";

+	str.replace(L"killme", L"");

+	if ( str != L"now" )

+		return false;

+

+	// remove nothing

+	str = L"keepme";

+	str.replace(L"", L"whatever");

+	if ( str != L"keepme" )

+		return false;

+

+	str = L"keepme";

+	str.replace(L"", L"");

+	if ( str != L"keepme" )

+		return false;

+

+	return true;

+}

+

+

+bool testAppendStringc()

+{

+	core::stringc str;

+	// Test with character

+	if (str != "")

+		return false;

+	str += 'W';

+	if (str != "W")

+		return false;

+	str += 'i';

+	if (str != "Wi")

+		return false;

+	str="";

+	if (str != "")

+		return false;

+

+	// Test with C-style string

+	str += "Another Test";

+	if (str != "Another Test")

+		return false;

+	str="";

+	str += 'A';

+	str += "nother Test";

+	if (str != "Another Test")

+		return false;

+	str="";

+

+	// Test with int

+	str += 10;

+	if (str != "10")

+		return false;

+	str += 0;

+	if (str != "100")

+		return false;

+	str="";

+	str += "-32";

+	if (str != "-32")

+		return false;

+	str="";

+

+	// Test with unsigned int

+	str += 21u;

+	if (str != "21")

+		return false;

+	str += 0u;

+	if (str != "210")

+		return false;

+	str="";

+

+	// Test with long int

+	str += 456l;

+	if (str != "456")

+		return false;

+	str += 0l;

+	if (str != "4560")

+		return false;

+	str="";

+	str += -456l;

+	if (str != "-456")

+		return false;

+	str="";

+

+	// Test with unsigned long

+	str += 994ul;

+	if (str != "994")

+		return false;

+	str += 0ul;

+	if (str != "9940")

+		return false;

+	str="";

+	return true;

+}

+

+bool testInsert()

+{

+	core::stringc str;

+

+	str.insert(0, "something", 4);

+	if (str != "some")

+		return false;

+

+	str.insert(4, "thing", 5);

+	if (str != "something")

+		return false;

+

+	str.insert(0, "is ", 3);

+	if (str != "is something")

+		return false;

+

+	str.insert(3, "there ", 6);

+	if (str != "is there something")

+		return false;

+

+	return true;

+}

+

+bool testLowerUpper()

+{

+	irr::core::array <irr::core::stringc> stringsOrig, targetLower, targetUpper;

+	stringsOrig.push_back("abc");

+	targetLower.push_back("abc");

+	targetUpper.push_back("ABC");

+	stringsOrig.push_back("ABC");

+	targetLower.push_back("abc");

+	targetUpper.push_back("ABC");

+	stringsOrig.push_back("Abc");

+	targetLower.push_back("abc");

+	targetUpper.push_back("ABC");

+	stringsOrig.push_back("aBBc");

+	targetLower.push_back("abbc");

+	targetUpper.push_back("ABBC");

+	stringsOrig.push_back("abC");

+	targetLower.push_back("abc");

+	targetUpper.push_back("ABC");

+	stringsOrig.push_back("");

+	targetLower.push_back("");

+	targetUpper.push_back("");

+	/* TODO: those are not supported so far

+	stringsOrig.push_back("ßäöü");

+	targetLower.push_back("ßäöü");

+	targetUpper.push_back("ßÄÖÜ");

+	stringsOrig.push_back("ßÄÖÜ");

+	targetLower.push_back("ßäöü");

+	targetUpper.push_back("ßÄÖÜ");

+	*/

+

+	for ( irr::u32 i=0; i<stringsOrig.size(); ++i )

+	{

+		irr::core::stringc c = stringsOrig[i];

+		c.make_lower();

+		if ( c != targetLower[i] )

+		{

+			logTestString("make_lower for stringc failed in test %d %s\n", i, stringsOrig[i].c_str());

+			return false;

+		}

+

+		c = stringsOrig[i];

+		c.make_upper();

+		if ( c != targetUpper[i] )

+		{

+			logTestString("make_upper for stringc failed in test %d %s %s\n", i, stringsOrig[i].c_str(), c.c_str());

+			return false;

+		}

+

+		irr::core::stringw w = irr::core::stringw(stringsOrig[i]);

+		c.make_lower();

+		if ( c != irr::core::stringw(targetLower[i]) )

+		{

+			logTestString("make_lower for stringw failed in test %d %s\n", i, stringsOrig[i].c_str());

+			return false;

+		}

+

+		c = irr::core::stringw(stringsOrig[i]);

+		c.make_upper();

+		if ( c != irr::core::stringw(targetUpper[i]) )

+		{

+			logTestString("make_upper for stringw failed in test %d %s\n", i, stringsOrig[i].c_str());

+			return false;

+		}

+	}

+

+	return true;

+}

+

+bool testFindFunctions()

+{

+	irr::core::stringc dot(".");

+	irr::s32 p = dot.findFirst(0);

+	if ( p >= 0 )

+		return false;

+

+	irr::core::stringc empty("");

+	p = empty.findLastCharNotInList("x",1);

+	if ( p >= 0 )

+		return false;

+

+	irr::core::stringc lastX("max");

+	p = lastX.findLastCharNotInList("x",1);

+	if ( p != 1 )

+		return false;

+	p = lastX.findLastCharNotInList("y",1);

+	if ( p != 2 )

+		return false;

+

+	p = empty.findLast('x');

+	if ( p >= 0 )

+		return false;

+

+	p = dot.findLast('.');

+	if ( p != 0 )

+		return false;

+

+	p = empty.findLastChar("ab", 2);

+	if ( p >= 0 )

+		return false;

+

+	p = dot.findLastChar("-.", 2);

+	if ( p != 0 )

+		return false;

+

+	return true;

+}

+

+bool testErase()

+{

+	if ( stringc(1.f).eraseTrailingFloatZeros() != stringc("1") )

+		return false;

+

+	if ( stringc("0.100000").eraseTrailingFloatZeros() != stringc("0.1") )

+		return false;

+

+	if ( stringc("10.000000").eraseTrailingFloatZeros() !=  stringc("10") )

+		return false;

+

+	if ( stringc("foo 3.140000").eraseTrailingFloatZeros() != stringc("foo 3.14") )

+		return false;

+

+	if ( stringc("no_num.000").eraseTrailingFloatZeros() != stringc("no_num.000") )

+		return false;

+

+	if ( stringc("1.").eraseTrailingFloatZeros() != stringc("1.") )

+		return false;

+

+	return true;

+}

+

+// Test the functionality of irrString

+/** Validation is done with assert_log() against expected results. */

+bool testIrrString(void)

+{

+	bool allExpected = true;

+

+	logTestString("Test stringc\n");

+	{

+		// Check empty string

+		core::stringc empty;

+		assert_log(empty.size()==0);

+		assert_log(empty[0]==0);

+		assert_log(empty.c_str()!=0);

+		assert_log(*(empty.c_str())==0);

+		// Assign content

+		empty = "Test";

+		assert_log(empty.size()==4);

+		assert_log(empty[0]=='T');

+		assert_log(empty[3]=='t');

+		assert_log(*(empty.c_str())=='T');

+		//Assign empty string, should be same as in the beginning

+		empty = "";

+		assert_log(empty.size()==0);

+		assert_log(empty[0]==0);

+		assert_log(*(empty.c_str())==0);

+	}

+	logTestString("Test stringw\n");

+	{

+		core::stringw empty;

+		assert_log(empty.size()==0);

+		assert_log(empty[0]==0);

+		assert_log(empty.c_str()!=0);

+		assert_log(*(empty.c_str())==0);

+		empty = L"Test";

+		assert_log(empty.size()==4);

+		assert_log(empty[0]==L'T');

+		assert_log(empty[3]=='t');

+		assert_log(*(empty.c_str())==L'T');

+		empty = L"";

+		assert_log(empty.size()==0);

+		assert_log(empty[0]==0);

+		assert_log(*(empty.c_str())==0);

+		assert_log(allExpected &= testSplit());

+	}

+	allExpected &= testAppendStringc();

+

+	allExpected &= testInsert();

+

+	logTestString("Test io::path\n");

+	{

+		// Only test that this type exists, it's one from above

+		io::path myPath;

+		myPath = "Some text"; // Only to avoid wrong optimizations

+	}

+

+	logTestString("Test self assignment\n");

+	allExpected &= testSelfAssignment();

+

+	logTestString("test fast alloc\n");

+	allExpected &= testFastAlloc();

+

+	logTestString("test replace\n");

+	allExpected &= testReplace();

+

+	logTestString("test make_lower and make_uppers\n");

+	allExpected &= testLowerUpper();

+

+	logTestString("test find functions\n");

+	allExpected &= testFindFunctions();

+

+	logTestString("test erase functions\n");

+	allExpected &= testErase();

+

+	if(allExpected)

+		logTestString("\nAll tests passed\n");

+	else

+		logTestString("\nFAIL!\n");

+

+	return allExpected;

+}