diff -r c55016431358 -r 0a7b44b10206 symport/e32test/buffer/T_FoldPerf.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symport/e32test/buffer/T_FoldPerf.cpp Thu Jun 25 15:59:54 2009 +0100 @@ -0,0 +1,712 @@ +// 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 + +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 text(KText16); + + TBufC16<3> searchStr1(_L16("gUw")); + + const TText16 searchText2[] = {0x01D5, 'A', 'b', 0}; + TBufC16 searchStr2(searchText2); + + const TText16 searchText3[] = {0x0075, 0x0308, 0x0304, 'A', 'b', 0}; + TBufC16 searchStr3(searchText3); + + const TText16 searchText4[] = {0x095E, 'd', 'A', 'b', 0}; + TBufC16 searchStr4(searchText4); + + const TText16 searchText5[] = {0x095E, 0x0055, 0x0308, 0x0304, 'A', 'b', 'C', 0}; + TBufC16 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 text(KText16); + + TBufC16<11> searchStr1(_L16("*fa??5*W*a*")); + + const TText16 searchText2[] = {'*', 0x01D5, 'A', '?', 'C', '*', 0}; + TBufC16 searchStr2(searchText2); + + const TText16 searchText3[] = {'*', 0x0075, 0x0308, 0x0304, '*', 'e', 'F', 0}; + TBufC16 searchStr3(searchText3); + + const TText16 searchText4[] = {'1', '*', 'A', 'b', '*', 0}; + TBufC16 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 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 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 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 oriUnicodeLargeText(largeUnicodeText16); + TBufC16 oriUnicodeSmallText(smallUnicodeText16); + + TBufC16 matchUnicodeLargeText(largeUnicodeText16); + TBufC16 matchUnicodeSmallText(smallUnicodeText16); + + TBufC16 nonMatchUnicodeLargeTextLast(largeErrUnicodeTextLast16); + TBufC16 nonMatchUnicodeLargeTextFirst(largeErrUnicodeTextFirst16); + + TBufC16 nonMatchUnicodeSmallTextLast(smallErrUnicodeTextLast16); + TBufC16 nonMatchUnicodeSmallTextFirst(smallErrUnicodeTextFirst16); + + // (16-bit) Unicode/Ascii Set of variables + + TBufC16 oriMixedLargeText(largeMixedText16); + TBufC16 oriMixedSmallText(smallMixedText16); + + TBufC16 matchMixedLargeText(largeMixedText16); + TBufC16 matchMixedSmallText(smallMixedText16); + + TBufC16 nonMatchMixedLargeTextLast(largeErrMixedTextLast16); + TBufC16 nonMatchMixedLargeTextFirst(largeErrMixedTextFirst16); + + TBufC16 nonMatchMixedSmallTextLast(smallErrMixedTextLast16); + TBufC16 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 + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Last Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, nonMatchAsciiLargeTextLast8, EFalse, -9); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / First Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, nonMatchAsciiLargeTextFirst8, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Last Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, nonMatchAsciiSmallTextLast8, EFalse, -19); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / First Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, nonMatchAsciiSmallTextFirst8, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Last Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, nonMatchAsciiSmallTextLast8, EFalse, -19); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / First Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, nonMatchAsciiSmallTextFirst8, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Last Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, nonMatchAsciiLargeTextLast8, EFalse, -45); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / First Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, nonMatchAsciiLargeTextFirst8, EFalse, -23); + + // Mismatching length (8-bit) Ascii + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Length Mismatch / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText8, oriAsciiLargeText8, EFalse, -45); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Length Mismatch / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText8, oriAsciiSmallText8, EFalse, 45); + + TheTest.Printf(_L("\n====== (16-bit) Ascii Performance tests ======")); + + // Matching (16-bit) Ascii + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Large Ascii Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, matchAsciiLargeText, ETrue); + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Small Ascii Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, matchAsciiSmallText, ETrue); + + // Non Matching (16-bit) Ascii + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Last Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, nonMatchAsciiLargeTextLast, EFalse, -9); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / First Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, nonMatchAsciiLargeTextFirst, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Last Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, nonMatchAsciiSmallTextLast, EFalse, -19); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / First Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, nonMatchAsciiSmallTextFirst, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Last Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, nonMatchAsciiSmallTextLast, EFalse, -19); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / First Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, nonMatchAsciiSmallTextFirst, EFalse, -23); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Last Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, nonMatchAsciiLargeTextLast, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / First Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, nonMatchAsciiLargeTextFirst, EFalse, -23); + + // Mismatching length (16-bit) Ascii + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Ascii Text / Length Mismatch / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiSmallText, oriAsciiLargeText, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Ascii Text / Length Mismatch / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriAsciiLargeText, oriAsciiSmallText, EFalse, 1); + + TheTest.Printf(_L("\n====== (16-bit) Unicode Performance tests ======")); + + // Matching (16-bit) Unicode + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Large Unicode Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, matchUnicodeLargeText, ETrue); + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Small Unicode Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, matchUnicodeSmallText, ETrue); + + // Non Matching (16-bit) Unicode + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Unicode Text / Last Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, nonMatchUnicodeLargeTextLast, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Unicode Text / First Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, nonMatchUnicodeLargeTextFirst, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Unicode Text / Last Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, nonMatchUnicodeSmallTextLast, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Unicode Text / First Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, nonMatchUnicodeSmallTextFirst, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Unicode Text / Last Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, nonMatchUnicodeSmallTextLast, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Unicode Text / First Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, nonMatchUnicodeSmallTextFirst, EFalse, -3); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Unicode Text / Last Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, nonMatchUnicodeLargeTextLast, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Unicode Text / First Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, nonMatchUnicodeLargeTextFirst, EFalse, -3); + + // Mismatching length (16-bit) Unicode + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Unicode Text / Length Mismatch / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeSmallText, oriUnicodeLargeText, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Unicode Text / Length Mismatch / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriUnicodeLargeText, oriUnicodeSmallText, EFalse, 1); + + TheTest.Printf(_L("\n====== (16-bit) Mixed Performance tests ======")); + + // Matching (16-bit) Mixed + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Large Mixed Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, matchMixedLargeText, ETrue); + + TheTest.Printf(_L("\nComparing Performance Times For: \nMatching Small Mixed Text\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, matchMixedSmallText, ETrue); + + // Non Matching (16-bit) Mixed + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Mixed Text / Last Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, nonMatchMixedLargeTextLast, EFalse, -655); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Mixed Text / First Char Diff / Large Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, nonMatchMixedLargeTextFirst, EFalse, -675); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Mixed Text / Last Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, nonMatchMixedSmallTextLast, EFalse, -655); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Mixed Text / First Char Diff / Small Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, nonMatchMixedSmallTextFirst, EFalse, -675); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Mixed Text / Last Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, nonMatchMixedSmallTextLast, EFalse, -655); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Mixed Text / First Char Diff / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, nonMatchMixedSmallTextFirst, EFalse, -675); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Mixed Text / Last Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, nonMatchMixedLargeTextLast, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Mixed Text / First Char Diff / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, nonMatchMixedLargeTextFirst, EFalse, -675); + + // Mismatching length (16-bit) Mixed + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Small Mixed Text / Length Mismatch / Small Vs Large\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedSmallText, oriMixedLargeText, EFalse, -1); + + TheTest.Printf(_L("\nComparing Performance Times For: \nNON Matching Large Mixed Text / Length Mismatch / Large Vs Small\n")); + RunComparison_PerformanceTest(numberOfTimes, oriMixedLargeText, oriMixedSmallText, EFalse, 1); + } + + + +TInt E32Main() + { + TheTest.Title(); + + TheTest.Start(_L("Folding - performance tests")); + + ::FindF_PerformanceTest(); + ::MatchF_PerformanceTest(); + ::CompareF_PerformanceTest(); + ::PlainTextPerformanceTest(); + ::CompareVsCompareF_PerformanceTest(); + + TheTest.End(); + TheTest.Close(); + + return KErrNone; + }