// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32test.h>

static RTest TheTest(_L("T_FoldPerf"));

#define ARRAY_SIZE(ar) (sizeof(ar) / (sizeof(ar[0])))

const TText16 KText16[] = {'1', 'f', 'A', 0x01D5, 'k', '5', 'g', 'U', 'W', 'q', 'a', 

                           0x095E, 0x01D5, 'a', 'B', 'c', 'd', 'E', 'F', 0};

//0x095E - DEVANAGARI LETTER FA

//decomposed to: 0x092B 0x093C

//0x01D5 - LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON

//decomposed to: 0x0075 0x0308 0x0304

_LIT16(KPlainText, "abcdefghijklmnopqrst");

/**

@SYMTestCaseID SYSLIB-UNICODE-CT-0108

@SYMTestCaseDesc FindF - performance test

@SYMTestPriority High

@SYMTestActions  FindF - performance test

@SYMTestExpectedResults The test must not fail.

@SYMPREQ814 Optimise folded string comparisons.

*/

static void FindF_PerformanceTest()

    {

	TheTest.Next(_L("FindF test"));

    TBufC16<ARRAY_SIZE(KText16) - 1> text(KText16);

    TBufC16<3> searchStr1(_L16("gUw"));

    const TText16 searchText2[] = {0x01D5, 'A', 'b', 0};

    TBufC16<ARRAY_SIZE(searchText2) - 1> searchStr2(searchText2);

    const TText16 searchText3[] = {0x0075, 0x0308, 0x0304, 'A', 'b', 0};

    TBufC16<ARRAY_SIZE(searchText3) - 1> searchStr3(searchText3);

    const TText16 searchText4[] = {0x095E, 'd', 'A', 'b', 0};

    TBufC16<ARRAY_SIZE(searchText4) - 1> searchStr4(searchText4);

    const TText16 searchText5[] = {0x095E, 0x0055, 0x0308, 0x0304, 'A', 'b', 'C', 0};

    TBufC16<ARRAY_SIZE(searchText5) - 1> searchStr5(searchText5);

    TBufC16<4> searchStr6(_L16("CDEF"));

    TUint timeStart = User::TickCount();

    for(TInt i=0;i<10000;++i)

        {

        TInt res = text.FindF(searchStr1);

        TheTest(res == 6);//searchStr1 starts at position 6

        res = text.FindF(searchStr2);

        TheTest(res == 12);

        res = text.FindF(searchStr3);

        TheTest(res == 12);

        res = text.FindF(searchStr4);

        TheTest(res == KErrNotFound);

        res = text.FindF(searchStr5);

        TheTest(res == 11);

        res = text.FindF(searchStr6);

        TheTest(res == 15);

        }

	TUint timeEnd = User::TickCount();

	TheTest.Printf(_L("Time = %d ticks\n"), timeEnd - timeStart);

    }

/**

@SYMTestCaseID SYSLIB-UNICODE-CT-0109

@SYMTestCaseDesc MatchF - performance test

@SYMTestPriority High

@SYMTestActions  MatchF - performance test

@SYMTestExpectedResults The test must not fail.

@SYMPREQ814 Optimise folded string comparisons.

*/

static void MatchF_PerformanceTest()

    {

	TheTest.Next(_L("MatchF test"));

    TBufC16<ARRAY_SIZE(KText16) - 1> text(KText16);

    TBufC16<11> searchStr1(_L16("*fa??5*W*a*"));

    const TText16 searchText2[] = {'*', 0x01D5, 'A', '?', 'C', '*', 0};

    TBufC16<ARRAY_SIZE(searchText2) - 1> searchStr2(searchText2);

    const TText16 searchText3[] = {'*', 0x0075, 0x0308, 0x0304, '*', 'e', 'F', 0};

    TBufC16<ARRAY_SIZE(searchText3) - 1> searchStr3(searchText3);

    const TText16 searchText4[] = {'1', '*', 'A', 'b', '*', 0};

    TBufC16<ARRAY_SIZE(searchText4) - 1> searchStr4(searchText4);

    TBufC16<11> searchStr5(_L16("*fa?z5*W*a*"));

    TBufC16<5> searchStr6(_L16("a?v?T"));

    TUint timeStart = User::TickCount();

    for(TInt i=0;i<10000;++i)

        {

        TInt res = text.MatchF(searchStr1);

        TheTest(res == 1);

        res = text.MatchF(searchStr2);

        TheTest(res == 12);

        res = text.MatchF(searchStr3);

        TheTest(res == 3);

        res = text.MatchF(searchStr4);

        TheTest(res == 0);

        res = text.MatchF(searchStr5);

        TheTest(res == KErrNotFound);

        res = text.MatchF(searchStr6);

        TheTest(res == KErrNotFound);

        }

	TUint timeEnd = User::TickCount();

	TheTest.Printf(_L("Time = %d ticks\n"), timeEnd - timeStart);

    }

/**

@SYMTestCaseID SYSLIB-UNICODE-CT-0110

@SYMTestCaseDesc CompareF - performance test

@SYMTestPriority High

@SYMTestActions  CompareF - performance test

@SYMTestExpectedResults The test must not fail.

@SYMPREQ814 Optimise folded string comparisons.

*/

static void CompareF_PerformanceTest()

    {

	TheTest.Next(_L("CompareF test"));

    TBufC16<ARRAY_SIZE(KText16) - 1> text(KText16);

    const TText16 text1[] = {'1', 'F', 'A', 0x01D5, 'k', '5', 'G', 'U', 'W', 'Q', 'A', 

                             0x095E, 0x01D5, 'a', 'B', 'C', 'd', 'E', 'F', 0};

    TBufC16<ARRAY_SIZE(text1) - 1> str1(text1);

    TBufC16<19> str2(_L16("1234567890123456789"));

    TBufC16<19> str3(_L16("1fA4G6789r1d34z6789"));

    TUint timeStart = User::TickCount();

    TInt i;

    for(i=0;i<10000;++i)

        {

        TInt res = text.CompareF(str1);

        TheTest(res == 0);

        res = text.CompareF(str2);

        TheTest(res != 0);

        res = text.CompareF(str3);

        TheTest(res != 0);

        }

	TUint timeEnd = User::TickCount();

	TheTest.Printf(_L("1. Time = %d ticks\n"), timeEnd - timeStart);

    TBufC16<20> str4(_L16("abc3456hijklmnopqrst"));

    timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        TInt res = str4.CompareF(KPlainText);

        TheTest(res != 0);

        }

	timeEnd = User::TickCount();

	TheTest.Printf(_L("2. Time = %d ticks\n"), timeEnd - timeStart);

    }

/**

@SYMTestCaseID SYSLIB-UNICODE-CT-0114

@SYMTestCaseDesc FindF(), CompareF(), MatchF() on plain (no combining characters) text

@SYMTestPriority High

@SYMTestActions  Performance test

@SYMTestExpectedResults The test must not fail.

@SYMPREQ814 Optimise folded string comparisons.

*/

static void PlainTextPerformanceTest()

    {

	TheTest.Next(_L("Plain text - performance test"));

    TInt res;

    TInt i;

    TBufC16<20> str1(_L16("abcdefghijklmnopqrst"));

    TBufC16<20> str2(_L16("abcDefghIjklmNOpqrsT"));

    TBufC16<20> str3(_L16("abcDefghIjKlmNOp2rsT"));

    TUint timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        res = KPlainText().CompareF(str1);

        TheTest(res == 0);

        res = KPlainText().CompareF(str2);

        TheTest(res == 0);

        res = KPlainText().CompareF(str3);

        TheTest(res != 0);

        }

	TUint timeEnd = User::TickCount();

	TheTest.Printf(_L("CompareF() Time = %d ticks\n"), timeEnd - timeStart);

    TBufC16<20> str4(_L16("gHiJk"));

    TBufC16<20> str5(_L16("Opqr"));

    TBufC16<20> str6(_L16("2rsT"));

    timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        res = KPlainText().FindF(str4);

        TheTest(res == 6);

        res = KPlainText().FindF(str5);

        TheTest(res == 14);

        res = KPlainText().FindF(str6);

        TheTest(res == KErrNotFound);

        }

	timeEnd = User::TickCount();

	TheTest.Printf(_L("FindF() Time = %d ticks\n"), timeEnd - timeStart);

    TBufC16<20> str7(_L16("*gHiJk*op??sT"));

    TBufC16<20> str8(_L16("aBC*rst"));

    TBufC16<20> str9(_L16("ab?D*2rsT"));

    timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        res = KPlainText().MatchF(str7);

        TheTest(res == 6);

        res = KPlainText().MatchF(str8);

        TheTest(res == 0);

        res = KPlainText().MatchF(str9);

        TheTest(res == KErrNotFound);

        }

	timeEnd = User::TickCount();

	TheTest.Printf(_L("MatchF() Time = %d ticks\n"), timeEnd - timeStart);

    TBufC16<21> str10(_L16("abcdefghijklmnopqrst"));

    TBufC16<20> str11(_L16("*xyz*"));

    TBufC16<20> str12(_L16("xyz"));

    timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        res = str10.FindF(str12);

        TheTest(res == KErrNotFound);

        }

	timeEnd = User::TickCount();

	TheTest.Printf(_L("Nonmatching string. FindF() Time = %d ticks\n"), timeEnd - timeStart);

    timeStart = User::TickCount();

    for(i=0;i<10000;++i)

        {

        res = str10.MatchF(str11);

        TheTest(res == KErrNotFound);

        res = str10.MatchF(str12);

        TheTest(res == KErrNotFound);

        }

	timeEnd = User::TickCount();

	TheTest.Printf(_L("Nonmatching string. MatchF() Time = %d ticks\n"), timeEnd - timeStart);

    }

static void RunComparison_PerformanceTest(TInt aNumberOfTimes, TDesC& aOriginalText, TDesC& aToCompareText, TBool aCase, TInt aValue = 0)

	{

	TUint timeStart;

	TUint timeEnd;

	TInt res = 0;

	TInt i;

	// CompareF() case...

	timeStart = User::TickCount();

	for(i=0; i<aNumberOfTimes; ++i)

        {

        res = aOriginalText.CompareF(aToCompareText);

        if(aCase)

        	TheTest(res == 0);

        else

        	TheTest(res != 0);

        }

    timeEnd = User::TickCount();

    TheTest.Printf(_L("Time to run (x%d) 16-bit CompareF() = %d ticks\n"), aNumberOfTimes, timeEnd - timeStart);

    // Check return value

    TheTest(res == aValue);

	// Compare() case...

	timeStart = User::TickCount();

	for(i=0; i<aNumberOfTimes; ++i)

        {

        res = aOriginalText.Compare(aToCompareText);

        if(aCase)

        	TheTest(res == 0);

        else

        	TheTest(res != 0);

        }

    timeEnd = User::TickCount();

    TheTest.Printf(_L("Time to run (x%d) 16-bit Compare() = %d ticks\n"), aNumberOfTimes, timeEnd - timeStart);

	}

static void RunComparison_PerformanceTest(TInt aNumberOfTimes, TDesC8& aOriginalText, TDesC8& aToCompareText, TBool aCase, TInt aValue = 0)

	{

	TUint timeStart;

	TUint timeEnd;

	TInt res = 0;

	TInt i;

	// CompareF() case...

	timeStart = User::TickCount();

	for(i=0; i<aNumberOfTimes; ++i)

        {

        res = aOriginalText.CompareF(aToCompareText);

        if(aCase)

        	TheTest(res == 0);

        else

        	TheTest(res != 0);

        }

    timeEnd = User::TickCount();

    TheTest.Printf(_L("Time to run (x%d) 8-bit CompareF() = %d ticks\n"), aNumberOfTimes, timeEnd - timeStart);

    // Check return value

    TheTest(res == aValue);

	// Compare() case...

	timeStart = User::TickCount();

	for(i=0; i<aNumberOfTimes; ++i)

        {

        res = aOriginalText.Compare(aToCompareText);

        if(aCase)

        	TheTest(res == 0);

        else

        	TheTest(res != 0);

        }

    timeEnd = User::TickCount();

    TheTest.Printf(_L("Time to run (x%d) 8-bit Compare() = %d ticks\n"), aNumberOfTimes, timeEnd - timeStart);

	}  

static void CompareVsCompareF_PerformanceTest()

	{

	TheTest.Next(_L("Compare verses CompareF test"));

	// Declare variables...

	TInt numberOfTimes = 100000;

	const TText16 smallUnicodeText16[] = {0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 0}; // 5 Characters

	const TText16 largeUnicodeText16[] = {0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

						   		 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 0};	// 50 Characters

	const TText16 smallErrUnicodeTextLast16[] = {0x01D5, 0x0308, 0x0304, 0x095E, 'X', 0}; // 5 Characters

	const TText16 smallErrUnicodeTextFirst16[] = {'X', 0x0308, 0x0304, 0x095E, 0x01D5, 0}; // 5 Characters

	const TText16 largeErrUnicodeTextLast16[] = {0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

						   		 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		 0x01D5, 0x0308, 0x0304, 0x095E, 'X', 0};	// 50 Characters

	const TText16 largeErrUnicodeTextFirst16[] = {'X', 0x0308, 0x0304, 0x095E, 0x01D5, 

						   		 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 

								 		  		  0x01D5, 0x0308, 0x0304, 0x095E, 0x01D5, 0};	// 50 Characters

	const TText16 smallMixedText16[] = {'A', 'B', 'C', 0x095E, 0x01D5,  0}; // 5 Characters

	const TText16 largeMixedText16[] = {'A', 'B', 'C', 0x095E, 0x01D5, 

						   		 		'F', 'G', 'H', 'I', 'J', 

								 		'K', 'L', 'M', 'N', 'O', 

								 		'P', 'Q', 'R', 'S', 'T', 

								 		'U', 'V', 'W', 'X', 'Y', 

								 		'Z', '1', '2', '3', '4', 

								 		'5', '6', '7', '8', '9', 

								 		'a', 'b', 'c', 'd', 'e', 

								 		'f', 'g', 'h', 'i', 'j', 

								 		'k', 'l', 'm', 0x095E, 0x01D5, 0}; // 50 Characters

	const TText16 smallErrMixedTextLast16[] = {'A', 'B', 'C', 0x095E, 0x0304,  0}; // 5 Characters

	const TText16 smallErrMixedTextFirst16[] = {0x0304, 'B', 'C', 0x095E, 0x01D5,  0}; // 5 Characters

	const TText16 largeErrMixedTextLast16[] = {'A', 'B', 'C', 0x095E, 0x01D5, 

						   		 			   'F', 'G', 'H', 'I', 'J', 

								 			   'K', 'L', 'M', 'N', 'O', 

								 			   'P', 'Q', 'R', 'S', 'T', 

								 			   'U', 'V', 'W', 'X', 'Y', 

								 			   'Z', '1', '2', '3', '4', 

								 			   '5', '6', '7', '8', '9', 

								 			   'a', 'b', 'c', 'd', 'e', 

								 			   'f', 'g', 'h', 'i', 'j', 

								 			   'k', 'l', 'm', 0x095E, 0x0304, 0}; // 50 Characters

	const TText16 largeErrMixedTextFirst16[] = {0x0304, 'B', 'C', 0x095E, 0x01D5, 

						   		 				'F', 'G', 'H', 'I', 'J', 

						   		 				'K', 'L', 'M', 'N', 'O', 

						   		 				'P', 'Q', 'R', 'S', 'T', 

						   		 				'U', 'V', 'W', 'X', 'Y', 

						   		 				'Z', '1', '2', '3', '4', 

						   		 				'5', '6', '7', '8', '9', 

						   		 				'a', 'b', 'c', 'd', 'e', 

						   		 				'f', 'g', 'h', 'i', 'j', 

						   		 				'k', 'l', 'm', 0x095E, 0x01D5, 0}; // 50 Characters

	// (16-bit) Ascii Set of variables

	TBufC16<50> oriAsciiLargeText(_L("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno")); 

	TBufC16<5> oriAsciiSmallText(_L("ABCDE"));

	TBufC16<50> matchAsciiLargeText(_L("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno"));

	TBufC16<5> matchAsciiSmallText(_L("ABCDE"));

	TBufC16<50> nonMatchAsciiLargeTextLast(_L("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmnX"));

	TBufC16<50> nonMatchAsciiLargeTextFirst(_L("XBCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno"));

	TBufC16<5> nonMatchAsciiSmallTextLast(_L("ABCDX"));

	TBufC16<5> nonMatchAsciiSmallTextFirst(_L("XBCDE"));

	// (8-bit) Ascii Set of variables

	TBufC8<50> oriAsciiLargeText8(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno"));

	TBufC8<5> oriAsciiSmallText8(_L8("ABCDE"));

	TBufC8<50> matchAsciiLargeText8(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno"));

	TBufC8<5> matchAsciiSmallText8(_L8("ABCDE"));

	TBufC8<50> nonMatchAsciiLargeTextLast8(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmnX"));

	TBufC8<50> nonMatchAsciiLargeTextFirst8(_L8("XBCDEFGHIJKLMNOPQRSTUVWXYZ123456789abcdefghijklmno"));

	TBufC8<5> nonMatchAsciiSmallTextLast8(_L8("ABCDX"));

	TBufC8<5> nonMatchAsciiSmallTextFirst8(_L8("XBCDE"));

	// (16-bit) Unicode Set of variables

	TBufC16<ARRAY_SIZE(largeUnicodeText16) - 1> oriUnicodeLargeText(largeUnicodeText16);

	TBufC16<ARRAY_SIZE(smallUnicodeText16) - 1> oriUnicodeSmallText(smallUnicodeText16);

	TBufC16<ARRAY_SIZE(largeUnicodeText16) - 1> matchUnicodeLargeText(largeUnicodeText16);

	TBufC16<ARRAY_SIZE(smallUnicodeText16) - 1> matchUnicodeSmallText(smallUnicodeText16);

	TBufC16<ARRAY_SIZE(largeErrUnicodeTextLast16) - 1> nonMatchUnicodeLargeTextLast(largeErrUnicodeTextLast16);

	TBufC16<ARRAY_SIZE(largeErrUnicodeTextFirst16) - 1> nonMatchUnicodeLargeTextFirst(largeErrUnicodeTextFirst16);

	TBufC16<ARRAY_SIZE(smallErrUnicodeTextLast16) - 1> nonMatchUnicodeSmallTextLast(smallErrUnicodeTextLast16);

	TBufC16<ARRAY_SIZE(smallErrUnicodeTextFirst16) - 1> nonMatchUnicodeSmallTextFirst(smallErrUnicodeTextFirst16);

	// (16-bit) Unicode/Ascii Set of variables

	TBufC16<ARRAY_SIZE(largeMixedText16) - 1> oriMixedLargeText(largeMixedText16);

	TBufC16<ARRAY_SIZE(smallMixedText16) - 1> oriMixedSmallText(smallMixedText16);

	TBufC16<ARRAY_SIZE(largeMixedText16) - 1> matchMixedLargeText(largeMixedText16);

	TBufC16<ARRAY_SIZE(smallMixedText16) - 1> matchMixedSmallText(smallMixedText16);

	TBufC16<ARRAY_SIZE(largeErrMixedTextLast16) - 1> nonMatchMixedLargeTextLast(largeErrMixedTextLast16);

	TBufC16<ARRAY_SIZE(largeErrMixedTextFirst16) - 1> nonMatchMixedLargeTextFirst(largeErrMixedTextFirst16);

	TBufC16<ARRAY_SIZE(smallErrMixedTextLast16) - 1> nonMatchMixedSmallTextLast(smallErrMixedTextLast16);

	TBufC16<ARRAY_SIZE(smallErrMixedTextFirst16) - 1> nonMatchMixedSmallTextFirst(smallErrMixedTextFirst16);

	// Run performance tests...

	TheTest.Printf(_L("\n====== (8-bit) Ascii Performance tests ======"));

	// Matching (8-bit) Ascii

	TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Large Ascii Text\n"));

	RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, matchAsciiLargeText8, ETrue);

	TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Small Ascii Text\n"));

	RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, matchAsciiSmallText8, ETrue);

	// Non Matching (8-bit) Ascii