// Copyright (c) 1996-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:

// e32test\buffer\t_match.cpp

// Overview:

// Test the match methods of TPtrC8 and TPtrC16 objects and the 

// TCharIterator TCombiningCharIterator, TCollationValueIterator

// and TCollationRawValueIterator classes.

// API Information:

// TPtrC8, TPtrC16, TCharIterator, TCombiningCharIterator,

// TCollationValueIterator, TCollationRawValueIterator

// Details:

// - Test and verify the results of TPtrC8 Match and MatchF methods

// on a variety of constant strings. Verify both match and mismatch

// conditions.

// - Test and verify the results of TPtrC16 Match and MatchF methods

// on a variety of constant strings. Verify both match and mismatch

// conditions.

// - For a TCharIterator object, test and verify:

// - basic character handling

// - ability to reset the iterator correctly

// - combining characters works as expected

// - ability to jump into the middle of combined characters

// - full-width variants are not modified

// - narrow strings work as expected

// - surrogate pairs work as expected

// - Using a TCombiningCharIterator object with a variety of character 

// strings as input, verify that the output is as expected.

// - Using TCollationValueIterator and TCollationRawValueIterator objects:

// - test the raw iterator 

// - test starting at different points in the iteration and verify capitals 

// are ignored at level 0

// - verify capitals are ignored at level 1

// - verify capitals do not match at level 2

// - check the TCollationValueIterator Restart method

// - test collation keys, when they success and when they fail halfway

// - exhaust the internal cache, verify object still works

// - test different decompositions at level 3

// - verify results are as expected

// - Test and verify the results of the TUnicodeFold::FindWildcardMatchFolded()

// method on a variety of constant strings: find a string within another 

// string, verify the offset into the candidate string if it is present, or 

// KErrNotFound if it is not.

// - Test and verify the results of the TUnicodeFold::FindFolded() method on 

// a variety of constant strings: compare two strings, verify return value.

// - Test and verify results of UnicodeFoldCase() on a variety of characters.

// - Test and verify results of MatchLeadingWildcards() on a variety of strings.

// - Test and verify results of MatchesHereFoldedWithPrefixTest() on a variety 

// of strings.

// - Test and verify results of LocateFolded() on a variety of strings.

// - Test and verify results of FindFoldedWithWildcard() and FindMatchFolded()

// on a variety of strings.

// - Test and verify results of TDesc.CompareF() on a variety of strings.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <f32file.h>

#include <collate.h>

#include "collateimp.h"

#include "compareimp.h"

#include "u32std.h"

#ifndef __TOOLS2__

///***************** copied from locale euser source code ***********************

static const TCollationMethod TheCollationMethod[] =

	{

		{

		KUidBasicCollationMethod,				// this is the standard unlocalised method

		NULL,									// null means use the standard table

		NULL,									// there's no override table

		0										// the flags are standard

		}

	};

static const TCollationDataSet TheCollationDataSet =

	{

	TheCollationMethod,

	1

	};

const LCharSet TheCharSet =

	{

	NULL,

	&TheCollationDataSet

	};

const LCharSet* GetLocaleCharSet()

	{

	return &TheCharSet;

	}

#endif

///*******************************************************************************

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

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

LOCAL_D RTest test(_L("T_MATCH"));

#ifndef __TOOLS2__

_LIT(KUnicodeTestDataFile, "z:\\Test\\UnicodeData.txt");

#else

_LIT(KUnicodeTestDataFile, "UnicodeData.txt");

#endif

static const TUint32 TheDevanagariKey[] = 

	{

	0x22a010b,0x22b010b,0x285010b,0xb109,0xb209,0xb309,0xb409,0xb509,

	0x6c5e609,0x6c6e609,0x6c7e609,0x6c8e609,0x6c9e609,0x6cae609,0x6cbe609,0x6cce609,

	0x6cde609,0x6cee609,0xba40109,0xba50109,0xba60109,0xba70109,0xba80109,0xba90109,

	0xbaa0109,0xbab0109,0xbac0109,0xbad0109,0xbae0109,0xbaf0109,0xbb00109,0xbb10109,

	0xbb20109,0xbb30109,0xbb40109,0xbb50109,0xbb60109,0xbb70109,0xbb80109,0xbb90109,

	0xbb9b109,0xbba0109,0xbbab109,0xbbb0109,0xbbbb109,0xbbc0109,0xbbd0109,0xbbe0109,

	0xbbf0109,0xbc00109,0xbc0b109,0xbc10109,0xbc20109,0xbc30109,0xbc40109,0xbc50109,

	0xbc5b109,0xbc60109,0xbc6b109,0xbc70109,0xbc80109,0xbc90109,0xbca0109,0xbcb0109,

	0xbcc0109,0xbccb109,0xbcd0109,0xbce0109,0xbceb109,0xbcf0109,0xbd00109,0xbd10109,

	0xbd20109,0xbd2b109,0xbd30109,0xbd3b109,0xbd40109,0xbd50109,0xbd5b109,0xbd60109,

	0xbd70109,0xbd80109,0xbd90109,0xbda0109,0xbdb0109,0xbdc0109,0xbdd0109,0xbde0109,

	0xbdf0109,0xbe00109,0xbe10109,0xbe20109,0xbe30109,0xbe40109,0xbe50109,0xbe60109,

	0xbe70109,0xbe80109,0xbe90109,0xbea0109,0xbeb0109,0xbec0109,0xbed0109,

	};

static const TUint32 TheDevanagariIndex[] = 

	{

	0x9010012,0x9020013,0x9030014,0x9050015,0x9060016,0x9070017,0x9080018,0x9090019,

	0x90a001a,0x90b001b,0x90c001d,0x90d001f,0x90e0020,0x90f0021,0x9100022,0x9110023,

	0x9120024,0x9130025,0x9140026,0x9150027,0x9160029,0x917002b,0x918002d,0x919002e,

	0x91a002f,0x91b0030,0x91c0031,0x91d0033,0x91e0034,0x91f0035,0x9200036,0x9210037,

	0x9220039,0x923003b,0x924003c,0x925003d,0x926003e,0x927003f,0x9280040,0x9290041,

	0x92a0042,0x92b0043,0x92c0045,0x92d0046,0x92e0047,0x92f0048,0x930004a,0x931004b,

	0x932004c,0x933004d,0x934004e,0x935004f,0x9360050,0x9370051,0x9380052,0x9390053,

	0x93c0003,0x93d0054,0x93e0055,0x93f0056,0x9400057,0x9410058,0x9420059,0x943005a,

	0x944005b,0x945005e,0x946005f,0x9470060,0x9480061,0x9490062,0x94a0063,0x94b0064,

	0x94c0065,0x94d0066,0x9510004,0x9520005,0x9530006,0x9540007,0x9580028,0x959002a,

	0x95a002c,0x95b0032,0x95c0038,0x95d003a,0x95e0044,0x95f0049,0x960001c,0x961001e,

	0x962005c,0x963005d,0x9640000,0x9650001,0x9660008,0x9670009,0x968000a,0x969000b,

	0x96a000c,0x96b000d,0x96c000e,0x96d000f,0x96e0010,0x96f0011,0x9700002,

	};

static const TCollationKeyTable TheDevanagariTable = 

	{ TheDevanagariKey, TheDevanagariIndex, 103, 0, 0, 0 };

static const TCollationMethod TheDevanagariMethod =

	{ 0, 0, &TheDevanagariTable, 0 };

static const TCollationMethod TheDevanagariIgnoreCombiningMethod =

	{ 0, 0, &TheDevanagariTable, TCollationMethod::EIgnoreCombining };

static const TUint32 TheSwedishKey[] = 

	{

	0x8f60109,0x8f70109,0x8f80109,0x8f60121,0x8f70121,0x8f80121,0x8dd0109,0x8dd0121,

	0x8c50121,0x8c50109,

	};

static const TUint32 TheSwedishIndex[] = 

	{

	0x570008,0x770009,

	};

static const TUint16 TheSwedishStringElement[] = 

	{

	0x2,0x61,0x30a,0x2,0x61,0x308,0x2,0x6f,

	0x308,0x2,0x41,0x30a,0x2,0x41,0x308,0x2,

	0x4f,0x308,0x2,0x75,0x308,0x2,0x55,0x308,

	};

static const TUint32 TheSwedishStringIndex[] = 

	{

	0xc0004,0x90003,0xf0005,0x150007,0x30001,0x0,0x60002,0x120006,

	};

static const TCollationKeyTable TheSwedishTable = 

	{ TheSwedishKey, TheSwedishIndex, 2, TheSwedishStringElement, TheSwedishStringIndex, 8 };

static const TCollationMethod TheSwedishMethod =

	{ 0, 0, &TheSwedishTable, TCollationMethod::EIgnoreNone };

static const TCollationMethod TheIgnoreNoneMethod =

	{ 0, 0, 0, TCollationMethod::EIgnoreNone };

void TestPrintCaption(const TDesC& aTestName, const TText16 aStr[], TInt aLen)

	{

	test.Next(aTestName);

	RDebug::Print(_L("Char seq: "));

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

		{

		RDebug::Print(_L("%04X "), aStr[i]);

		}

	RDebug::Print(_L("\nOutput: "));

	}

TInt MatchC(const TDesC16& aCandidate, const TDesC16& aSearchTerm,

	const TCollationMethod* aMethod, TInt aLevel)

	{

	TCollate method(0);

	if (aMethod)

		{

		TCollate m(*aMethod);

		method = m;

		}

	return method.Match(aCandidate.Ptr(), aCandidate.Length(),

		aSearchTerm.Ptr(), aSearchTerm.Length(), aLevel);

	}

_LIT(KCand1, "baot");

_LIT(KCand2, "ba\x308o\x308t");

_LIT(KCand3, "b\xe4\xf6t");

_LIT(KSearch1, "BAOT");

_LIT(KSearch2, "?AO?");

_LIT(KSearch3, "?\xe4o?");

_LIT(KSearch4, "*o*");

_LIT(KSearch5, "*ao*");

_LIT(KSearch6, "*b\x308*");

_LIT(KSearch7, "ba\x308*");

_LIT(KSearch8, "ba*");

void TestMatchC()

	{

	// MatchC should be working at level 0, let us test that this is so.

	test(0 == KCand1().MatchC(KSearch1));

	test(0 == KCand1().MatchC(KCand2));

	test(1 == KCand1().MatchC(KSearch5));

	test(1 == KCand2().MatchC(KSearch5));

	test(0 <= KCand1().MatchC(KSearch2));

	// Test the internals at level 0: It must fail to match Swedish accents

	// with the Swedish collation algorithm.

	test(0 == MatchC(KCand1, KSearch1, &TheIgnoreNoneMethod, 0));

	test(0 == MatchC(KCand1, KSearch1, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand2, KSearch1, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand2, KSearch1, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand3, KSearch1, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand3, KSearch1, &TheSwedishMethod, 0));

	test(0 <= MatchC(KCand1, KSearch2, &TheIgnoreNoneMethod, 0));

	test(0 <= MatchC(KCand1, KSearch2, &TheSwedishMethod, 0));

	test(0 <= MatchC(KCand2, KSearch2, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand2, KSearch2, &TheSwedishMethod, 0));

	test(0 <= MatchC(KCand3, KSearch2, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand3, KSearch2, &TheSwedishMethod, 0));

	test(0 <= MatchC(KCand2, KSearch3, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand3, KSearch2, &TheSwedishMethod, 0));

	test(3 == MatchC(KCand2, KSearch4, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand2, KSearch4, &TheSwedishMethod, 0));

	test(1 == MatchC(KCand2, KSearch5, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand2, KSearch5, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand2, KSearch6, &TheIgnoreNoneMethod, 0));

	test(0 == MatchC(KCand2, KSearch6, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand1, KSearch7, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand1, KSearch7, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand1, KSearch8, &TheIgnoreNoneMethod, 0));

	test(0 == MatchC(KCand1, KSearch8, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand2, KSearch7, &TheIgnoreNoneMethod, 0));

	test(0 == MatchC(KCand2, KSearch7, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand2, KSearch8, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand2, KSearch8, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand3, KSearch7, &TheIgnoreNoneMethod, 0));

	test(0 == MatchC(KCand3, KSearch7, &TheSwedishMethod, 0));

	test(0 == MatchC(KCand3, KSearch8, &TheIgnoreNoneMethod, 0));

	test(KErrNotFound == MatchC(KCand3, KSearch8, &TheSwedishMethod, 0));

	_LIT(KCandidate1, "axyz");

	_LIT(KSearchStr1, "a*z");

	test(0 == KCandidate1().MatchC(KSearchStr1()));

	_LIT(KCandidate2, "azzz");

	_LIT(KSearchStr2, "a*z");

	test(0 == KCandidate2().MatchC(KSearchStr2()));

	// Added tests for INC105311...

	_LIT(KCandJpg1, "jpg_jjg.jpg");

	_LIT(KCandJpg2, "jpgAjjg.jpg");

	_LIT(KCandJpg3, "jpg@jjg.jpg");

	_LIT(KCandJpg4, "hpg&jjg.jpg");

	_LIT(KCandJpg5, "hpg&jpg.jpg");

	_LIT(KSearchJpg1, "*jp?");

	_LIT(KSearchJpg2, "*jpg");

	_LIT(KSearchJpg3, "*jpg*");

	_LIT(KSearchJpg4, "*jpg*jpg");

	test(8 == KCandJpg1().MatchC(KSearchJpg1));

	test(8 == KCandJpg2().MatchC(KSearchJpg1));

	test(8 == KCandJpg3().MatchC(KSearchJpg1));

	test(8 == KCandJpg4().MatchC(KSearchJpg1));

	test(8 == KCandJpg5().MatchC(KSearchJpg1));

	test(8 == KCandJpg1().MatchC(KSearchJpg2));

	test(8 == KCandJpg2().MatchC(KSearchJpg2));

	test(8 == KCandJpg3().MatchC(KSearchJpg2));

	test(8 == KCandJpg4().MatchC(KSearchJpg2));

	test(8 == KCandJpg5().MatchC(KSearchJpg2));

	test(0 == KCandJpg1().MatchC(KSearchJpg3));

	test(0 == KCandJpg2().MatchC(KSearchJpg3));

	test(0 == KCandJpg3().MatchC(KSearchJpg3));

	test(8 == KCandJpg4().MatchC(KSearchJpg3));

	test(4 == KCandJpg5().MatchC(KSearchJpg3));

	test(0 == KCandJpg1().MatchC(KSearchJpg4));

	test(0 == KCandJpg2().MatchC(KSearchJpg4));

	test(0 == KCandJpg3().MatchC(KSearchJpg4));

	test(KErrNotFound == KCandJpg4().MatchC(KSearchJpg4)); 

	test(4 == KCandJpg5().MatchC(KSearchJpg4));

	_LIT(KCand4, "abcxaxaxa");

	_LIT(KSearch9, "*xaxa");

	test(5 == KCand4().MatchC(KSearch9));

	_LIT(KCand6, "abxa");

	_LIT(KSearch10, "*x?");

	test(2 == KCand6().MatchC(KSearch10));

	_LIT(KCand7, "xab"); 

	_LIT(KSearch11, "x?");

	test(KErrNotFound == KCand7().MatchC(KSearch11));

	_LIT(KCand8, "xa"); 

	_LIT(KSearch12, "x?");

	test(0 == KCand8().MatchC(KSearch12));

	_LIT(KCand9, "xaxa"); 

	_LIT(KSearch13, "*x?");

	test(2 == KCand9().MatchC(KSearch13));

	_LIT(KCand10, "abjpgcjig.jpg"); 

	_LIT(KSearch14, "*jp?");

	test(10 == KCand10().MatchC(KSearch14));

	_LIT(KCand11, "abjpg_jig.jpg"); 

	_LIT(KSearch15, "*jp?");

	test(10 == KCand11().MatchC(KSearch15));

	_LIT(KCand12, "jpg"); 

	_LIT(KSearch16, "*jp?");

	test(0 == KCand12().MatchC(KSearch16));

	_LIT(KCand13, "abjpgig.jpg"); 

	_LIT(KSearch17, "*jp?");

	test(8 == KCand13().MatchC(KSearch17));

	_LIT(KCand14, "abjcgig.jpg"); 

	_LIT(KSearch18, "jp?");

	test(KErrNotFound == KCand14().MatchC(KSearch18));

	_LIT(KCand15, "xax\xE2"); 

	_LIT(KSearch19, "*xa\x302");

	test(2 == KCand15().MatchC(KSearch19));

	_LIT(KCand5, "blahblahblah\xE2");

	_LIT(KSearch20, "*a\x302");

	test(12 == KCand5().MatchC(KSearch20));

	_LIT(KCand16, "bl\xE2hblahblaha\x302");

	_LIT(KSearch21, "*a\x302*\xE2");

	test(2 == KCand16().MatchC(KSearch21));

	_LIT(KCand17, "abcxaxaxa");

	_LIT(KSearch22, "*x?x?");

	test(5 == KCand17().MatchC(KSearch22));

	}

/**

@SYMTestCaseID SYSLIB-EUSER-CT-1759

@SYMTestCaseDesc Various tests for the new TDesC16::MatchC() method. Testing that the new method works with

				 different wild card characters and different escape characters.

@SYMTestPriority High

@SYMTestActions  Test for TDesC16::MatchC(const TDesC16 &aPattern, TInt aMaxLevel, TInt aWildChar, TInt aWildSequenceChar, TInt aEscapeChar, const TCollationMethod* aCollationMethod = NULL).

@SYMTestExpectedResults The test must not fail.

@SYMREQ REQ5907

*/

void TestMatchC2()

	{

	_LIT(KCandidate1, "ab/cRRRdef__grt");

	_LIT(KSearchStr1, "ab//c%def/_/_grt");

	TInt rc = KCandidate1().MatchC(KSearchStr1(), '_', '%', '/', 0);

	test(rc == 0);

	_LIT(KCandidate2, "_*");

	_LIT(KSearchStr2, "/_/*");

	rc = KCandidate2().MatchC(KSearchStr2(), '_', '*', '/', 0);

	test(rc == 0);

	_LIT(KCandidate3, "aa");

	_LIT(KSearchStr3, "aaaa");

	rc = KCandidate3().MatchC(KSearchStr3(), '_', '%', 'a', 0);

	test(rc == 0);

	_LIT(KCandidate4, "\\4%3=1");

	_LIT(KSearchStr4, "\\\\4_3%");

	rc = KCandidate4().MatchC(KSearchStr4(), '_', '%', '\\', 0);

	test(rc == 0);

	_LIT(KCandidate5, "abcd&efgh");

	_LIT(KSearchStr5, "----!&efgh");

	rc = KCandidate5().MatchC(KSearchStr5(), '-', '&', '!', 0);

	test(rc == 0);

	_LIT(KCandidate6, "abc#1234:5678#xyz");

	_LIT(KSearchStr6, "#!#1234!:56::!##z");

	rc = KCandidate6().MatchC(KSearchStr6(), ':', '#', '!', 0);

	test(rc == 3);

	_LIT(KCandidate7, "abc#1234:5678#zzz");

	_LIT(KSearchStr7, "#!#1234!:56::!##z");

	rc = KCandidate7().MatchC(KSearchStr7(), ':', '#', '!', 0);

	test(rc == 3);

	_LIT(KCandidate8, "abc");

	_LIT(KSearchStr8, "a_c");

	rc = KCandidate8().MatchC(KSearchStr8(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate9, "abc");

	_LIT(KSearchStr9, "A_C");

	rc = KCandidate9().MatchC(KSearchStr9(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate10, "a_c");

	_LIT(KSearchStr10, "a7_c");

	rc = KCandidate10().MatchC(KSearchStr10(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate11, "a_c");

	_LIT(KSearchStr11, "A7_C");

	rc = KCandidate11().MatchC(KSearchStr11(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate12, "abc");

	_LIT(KSearchStr12, "a7_c");

	rc = KCandidate12().MatchC(KSearchStr12(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate13, "abc");

	_LIT(KSearchStr13, "A7_C");

	rc = KCandidate13().MatchC(KSearchStr13(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate14, "a7Xc");

	_LIT(KSearchStr14, "a7_c");

	rc = KCandidate14().MatchC(KSearchStr14(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate15, "a7Xc");

	_LIT(KSearchStr15, "A7_C");

	rc = KCandidate15().MatchC(KSearchStr15(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate16, "abcde");

	_LIT(KSearchStr16, "a%e");

	rc = KCandidate16().MatchC(KSearchStr16(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate17, "abcde");

	_LIT(KSearchStr17, "A%E");

	rc = KCandidate17().MatchC(KSearchStr17(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate18, "abcde");

	_LIT(KSearchStr18, "a7%e");

	rc = KCandidate18().MatchC(KSearchStr18(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate19, "abcde");

	_LIT(KSearchStr19, "A7%E");

	rc = KCandidate19().MatchC(KSearchStr19(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate20, "a7cde");

	_LIT(KSearchStr20, "a7%e");

	rc = KCandidate20().MatchC(KSearchStr20(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate21, "a7cde");

	_LIT(KSearchStr21, "A7%E");

	rc = KCandidate21().MatchC(KSearchStr21(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate22, "a7cde");

	_LIT(KSearchStr22, "a77%e");

	rc = KCandidate22().MatchC(KSearchStr22(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate23, "a7cde");

	_LIT(KSearchStr23, "A77%E");

	rc = KCandidate23().MatchC(KSearchStr23(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate24, "abc7");

	_LIT(KSearchStr24, "a%77");

	rc = KCandidate24().MatchC(KSearchStr24(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate25, "abc7");

	_LIT(KSearchStr25, "A%77");

	rc = KCandidate25().MatchC(KSearchStr25(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate26, "abc_");

	_LIT(KSearchStr26, "a%7_");

	rc = KCandidate26().MatchC(KSearchStr26(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate27, "abc_");

	_LIT(KSearchStr27, "A%7_");

	rc = KCandidate27().MatchC(KSearchStr27(), '_', '%', '7', 0);

	test(rc == 0);

	_LIT(KCandidate28, "abc7");

	_LIT(KSearchStr28, "a%7_");

	rc = KCandidate28().MatchC(KSearchStr28(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate29, "abc7");

	_LIT(KSearchStr29, "A%7_");

	rc = KCandidate29().MatchC(KSearchStr29(), '_', '%', '7', 0);

	test(rc == KErrNotFound);

	_LIT(KCandidate30, "ba\x308o\x308t");

	_LIT(KSearchStr30, "-b\x308-");

	rc = KCandidate30().MatchC(KSearchStr30(), '%', '-', 0, 0);

	test(rc == 0);

	rc = KCandidate30().MatchC(KSearchStr30(), '%', '-', 0, 0, &TheSwedishMethod);

	test(rc == 0);

	_LIT(KSearchStr31, "ba\x308*");

	rc = KCandidate30().MatchC(KSearchStr31(), '%', '*', 0, 0, &TheSwedishMethod);

	test(rc == 0);

	}

void DoTestCanonicalDecompositionIterator(const TDesC& aTest, const TDesC& aCanonical)

	{

	TUTF32Iterator i(aTest.Ptr(), aTest.Ptr() + aTest.Length());

	TCanonicalDecompositionIterator cci;

	cci.Set(i);

	TInt index = 0;

	while (!cci.AtEnd())

		{

		test(index != aCanonical.Length());

		TChar ch1 = aCanonical[index];

		TChar ch2 = cci.Current();

		test(ch1 == ch2);

		++index;

		cci.Next();

		}

	test(index == aCanonical.Length());

	}

// exciting combining characters include:

// U+0327 cedilla, class = 202

// U+031B horn, class = 216

// U+0316 grave below, class = 220

// U+0300 grave above, class = 230

// U+031A left angle above, class = 232

// U+0360 double tilde, class = 234

// U+0345 ypogegrameni, class = 240

_LIT(KAllOnce, "\x327\x31b\x316\x300\x31a\x360\x345xyz");

_LIT(KBackwards, "\x345\x360\x31a\x300\x316\x31b\x327xyz");

_LIT(KRandom, "\x300\x316\x31b\x327\x31a\x345\x360xyz");

_LIT(KAllOnceThenAcute, "\x327\x31b\x316\x300\x301\x31a\x360\x345");

_LIT(KBackwardsThenAcute, "\x345\x360\x31a\x300\x301\x316\x31b\x327");

_LIT(KRandomThenAcute, "\x300\x316\x31b\x327\x31a\x301\x345\x360");

_LIT(KAllSame, "\x300\x301\x302\x303\x304\x306\x307\x308\x30b\x30c\x30f");