// 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:

// e32test\buffer\t_char.cpp

// Overview:

// Test TChar, TCharF, TChaLC and TCharUC character classes.

// API Information:

// TChar, TCharF, TChaLC, TCharUC.

// Details:

// - For different characters 

// - Verify character's standard category information

// - CR1080 verification of standard category information for additional Indic characters

// - Verify character's bi-directional Unicode character category.

// - Check if character is printable.

// - Check if character is a graphical character.

// - Verify for Chinese, Japanese, Korean (CJK) notional width.

// - Verify that it is upper case, lower case form.

// - Verify character's title case.

// - Verify mirrored property of character.

// - Verify integer numeric property of character.

// - Verify character can be decomposed.

// - For different unicode strings, verify unicode collation

// - Compare data of two descriptors using the different collation methods and 

// check results are as expected.

// - Call the methods in the TChar, TCharF, TCharUC and TCharUC

// - For TChar, TCharF, TChaLC, TCharUC

// - Check the constructor and operators are as expected.

// - Check folded character is same when it is converted to folded uppercase.

// - Check folded and uppercase character is same when it is converted to 

// uppercase letter stripped of accents.

// - Convert lowercase, uppercase characters to it's lowercase form, check the conversion 

// is as expected, and lowercase characters are unchanged.

// - Convert lowercase, uppercase characters to it's uppercase form, check the conversion 

// is as expected, and uppercase characters are unchanged.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <collate.h>	  

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

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

enum

	{

	Ydieresis=0x178,

	nobreakspace=160,

	exclamdown,

	cent,

	sterling,

	currency,

	yen,

	brokenbar,

	section,

	dieresis,

	copyright,

	ordfeminine,

	leftdoubleanglequote,

	logicalnot,

	softhyphen,

	registered,

	macron,

	degree,

	plusminus,

	twosuperior,

	threesuperior,

	acute,

	micro,

	pilcrow,

	dotaccent,

	cedilla,

	onesuperior,

	ordmasculine,

	rightdoubleanglequote,

	onequarter,

	onehalf,

	threequarters,

	questiondown,

	Agrave,

	Aacute,

	Acircumflex,

	Atilde,

	Adieresis,

	Aring,

	AE,

	Ccedilla,

	Egrave,

	Eacute,

	Ecircumflex,

	Edieresis,

	Igrave,

	Iacute,

	Icircumflex,

	Idieresis,

	Eth,

	Ntilde,

	Ograve,

	Oacute,

	Ocircumflex,

	Otilde,

	Odieresis,

	multiplication,

	Oslash,

	Ugrave,

	Uacute,

	Ucircumflex,

	Udieresis,

	Yacute,

	Thorn,

	germanbls,

	agrave,

	aacute,

	acircumflex,

	atilde,

	adieresis,

	aring,

	ae,

	ccedilla,

	egrave,

	eacute,

	ecircumflex,

	edieresis,

	igrave,

	iacute,

	icircumflex,

	idieresis,

	eth,

	ntilde,

	ograve,

	oacute,

	ocircumflex,

	otilde,

	odieresis,

	division,

	oslash,

	ugrave,

	uacute,

	ucircumflex,

	udieresis,

	yacute,

	thorn,

	ydieresis,

	Dzcaron = 0x01C5, 

	Lj = 0x01C8, 

	Udearesismacron = 0x01D5,

	Adotabove = 0x01E0,

	AEmacron = 0x01E2,

	aringacute = 0x01FB,

	scommabelow = 0x0219, 

	Otildemacron = 0x022C,

	Cstroke = 0x023B,

	doubleprime = 0x02BA, 

	lowleftarrow = 0x02FF,

	candrabindu = 0x0310, 

	doublerightwardsarrowbelow = 0x0362,

	latinsmalla = 0x0363	

	};

struct TCharDump

	{

	TUint iChar;

	};

/*EXPORT_C*/ void TChar::__DbgTest(void* pTCharDump) const

	{

	((TCharDump*)pTCharDump)->iChar=iChar;

	}

typedef enum {eTChar, eTCharF, eTCharC, eTCharLC, eTCharUC} TCharTypes;

template<class TCharType>	

class TestTChar

	{

public:

	void Test1();

	void Test2(TCharTypes);

	void Test3(TCharTypes);

	void Test4(TCharTypes);

	};

template<class TCharType>

GLDEF_C void TestTChar<TCharType>::Test1()

// Test that the methods are in the DLL

	{

	test.Start(_L("Test methods are in DLL - TChar"));

	TChar a('X');

	TUint TU=0;

	TChar b(TU);

	TChar c(b);

	c=TU;

	c=a;

	c-=TU;

	c+=TU;

	c-TU;

	c+TU;

	c=(TUint)(a);

	a.Fold();

	a.LowerCase();

	a.UpperCase();

	a.Eos();

	a.IsLower();

	a.IsUpper();

	a.IsAlpha();

	a.IsDigit();

	a.IsAlphaDigit();

	a.IsHexDigit();

	a.IsSpace();

	a.IsPunctuation();

	a.IsGraph();

	a.IsPrint();

//	a.SetChar(TU); protected

	test.Next(_L("Test methods are in DLL - TCharF"));	

	TCharF d(TU);

	TCharF e(a);

    e=d;

	e=TU;

	e=a;

	test.Next(_L("Test methods are in DLL - TCharLC"));	

	TCharLC h(TU);

	TCharLC i(a);

    h=i;

	h=TU;

	h=a;

	test.Next(_L("Test methods are in DLL - TCharUC"));	

	TCharUC j(TU);

	TCharUC k(a);

    k=j;

	k=TU;

	k=a;

	test.End();

	}

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

// Test the constructors

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

template<class TCharType>

GLDEF_C void TestTChar<TCharType>::Test2(TCharTypes CharType)

	{

	test.Start(_L("Test constructors"));

	TCharDump dump;

	TCharType b('x');

	b.__DbgTest(&dump);

	switch(CharType)

		{

		case eTChar:	

		case eTCharLC:

			test(dump.iChar=='x');

			break;

		case eTCharUC:

			test(dump.iChar=='X');

			break;

		case eTCharF:

		case eTCharC:

			test(dump.iChar == 'x');

		}

	test.End();

	}

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

// Test the operators

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

template<class TCharType>

GLDEF_C void TestTChar<TCharType>::Test3(TCharTypes CharType)

	{

	test.Start(_L("Test the operators")); 

	test.Next(_L("="));

	TCharDump dump;

	TUint TUx='x', TUX='X';

	TChar TCy='y', TCY='Y';

	TCharType aChar('m');

	aChar=TUx;

	aChar.__DbgTest(&dump);

	switch(CharType)

		{

		case eTChar:	

		case eTCharLC:	test(dump.iChar=='x'); break;

		case eTCharUC:	test(dump.iChar=='X'); break;

		case eTCharF:

		case eTCharC:	

			test(dump.iChar == 'x');

		}

	aChar=TUX; 

	aChar.__DbgTest(&dump);

	switch(CharType)

		{	

		case eTCharLC:	test(dump.iChar=='x'); break;

		case eTChar:

		case eTCharUC:	test(dump.iChar=='X'); break;

		case eTCharF:

		case eTCharC:	

			test(dump.iChar == 'x');

		}

	aChar=TCy;

	aChar.__DbgTest(&dump);

	switch(CharType)

		{

		case eTChar:	

		case eTCharLC:	test(dump.iChar=='y'); break;

		case eTCharUC:	test(dump.iChar=='Y'); break;

		case eTCharF:

		case eTCharC:	

			test(dump.iChar == 'y');

		}

	aChar=TCY;

	aChar.__DbgTest(&dump);

	switch(CharType)

		{	

		case eTCharLC:	test(dump.iChar=='y'); break;

		case eTChar:

		case eTCharUC:	test(dump.iChar=='Y'); break;

		case eTCharF:

		case eTCharC:	

			test(dump.iChar == 'y');

		}

	test.Next(_L("-=, +=, -, + and cast"));

	TCharType x(10);

	x-=5;

	x.__DbgTest(&dump);

	test(dump.iChar==5);

	x+=5;

	x.__DbgTest(&dump);

	test(dump.iChar==10);

	test((x-(TUint)5)==5);

	x.__DbgTest(&dump);

	test(dump.iChar==10);

	test((x+(TUint)5)==15);

	x.__DbgTest(&dump);

	test(dump.iChar==10);

	TChar z('a');

	TUint w=z;

	test(w==97);

	test.End();

	}

//////////////////////////////////////////////

// Test Fold, Fold(TChar::EFoldAccents), Collate, LowerCase, UpperCase

////////////////////////////////////////////

template<class TCharType>

GLDEF_C void TestTChar<TCharType>::Test4(TCharTypes CharType)

	{

	test.Start(_L("Fold(), Fold(TChar::EFoldAccents), Collate(), LowerCase() UpperCase() & Eos()"));

	TCharDump dump1, dump2;

	TCharType c(0);

	// Is the folded version the same as the folded uppercase version?

	test.Next(_L("Fold() 0-127"));

    TUint i;

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

		{

		c = i;

		c.Fold();

		c.__DbgTest(&dump1);

		c.UpperCase();

		c.Fold();

		c.__DbgTest(&dump2);

		test(dump1.iChar == dump2.iChar);

		}

	// Is the folded and uppercased version the same as an uppercase letter stripped of accents?

	test.Next(_L("Fold() >127"));

	for(i=128; i<=255; i++)

		{

		c=i;

		c.Fold();

		c.UpperCase();

		c.__DbgTest(&dump1);

		if(CharType==eTChar)

			{

			switch(i)

				{

			case ccedilla:	

			case Ccedilla:

                test(dump1.iChar=='C');

                break;

			case udieresis:	

			case ucircumflex:

			case ugrave:

			case uacute:		

			case Udieresis:

			case Ucircumflex:

			case Ugrave:

			case Uacute:

                test(dump1.iChar=='U');

                break;

			case ydieresis:

			case yacute:

			case Yacute:

                test(dump1.iChar=='Y');

                break;

			case ecircumflex:

			case edieresis:

			case egrave:

			case eacute:		

			case Ecircumflex:

			case Edieresis:

			case Egrave:

			case Eacute:

                test(dump1.iChar=='E');

                break;

			case acircumflex:

			case adieresis:

			case agrave:		

			case aacute:

			case Acircumflex: 

			case Adieresis:	

			case Agrave:			

			case Aacute:

			case atilde:

			case Atilde:

			case aring:		

			case Aring:

                test(dump1.iChar=='A');

                break;

			case idieresis:

			case icircumflex:

			case iacute:

			case igrave:			

			case Idieresis:

			case Icircumflex:

			case Iacute:

			case Igrave:

                test(dump1.iChar=='I');

                break;

			case ocircumflex:

			case odieresis:

			case ograve:

			case oacute:		

			case otilde:

			case Ocircumflex:

			case Odieresis:

			case Ograve:

			case Oacute:

			case Otilde:

                test(dump1.iChar=='O');

                break;

			case ntilde:

			case Ntilde:

                test(dump1.iChar=='N'); break;

			case oslash:

			case Oslash:

				test(dump1.iChar==Oslash); break;

			case ae:

			case AE:

				test(dump1.iChar==AE); break;

			case eth:

			case Eth:

                test(dump1.iChar==Eth); break;

			case thorn:

			case Thorn:

                test(dump1.iChar==Thorn);

                break;

			case nobreakspace:

				test(dump1.iChar == ' ');

				break;

			case micro:

				test(dump1.iChar == 0x039C);

				break;

			default:

                test(dump1.iChar==i); 

				}

			}

		}

	// In the following test section We test Fold(TChar::EFoldAccents) - This code tests this function for all the

	// set of unicode characters located between 0x0080 and 0x00FF which are already tested for Fold(). 

	// I added to this test 13 unicode character located between 0x01C5 and 0x0363.

	test.Next(_L("Fold(TChar::EFoldAccents) >127"));

	for(i=128; i<=255; i++)

		{

		c=i;

		c.Fold(TChar::EFoldAccents);

		c.__DbgTest(&dump1);

		if(CharType==eTChar)

			{