Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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 "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-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
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;
}