/*

* Copyright (c) 1997-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* 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 <e32std.h>

#include <e32test.h>

#include <utf.h>

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

RTest TheTest(_L("TError"));

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

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

//Tests macroses and functions.

//If (!aValue) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TheTest(EFalse, aLine);

		}

	}

//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

//Use these to test conditions.

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

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

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

typedef TInt (*FConvertFromUtfX)(TDes16& aUnicode, const TDesC8& aUtfX, TInt& aState);

LOCAL_C TInt ConvertToUnicodeFromUtf7(TDes16& aUnicode, const TDesC8& aUtf7, TInt& aState)

	{

	return CnvUtfConverter::ConvertToUnicodeFromUtf7(aUnicode, aUtf7, aState);

	}

LOCAL_C TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, TInt&)

	{

	return CnvUtfConverter::ConvertToUnicodeFromUtf8(aUnicode, aUtf8);

	}

LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtfX, FConvertFromUtfX aConvertFromUtfX)

	{

	enum {ECharacterCodeThatCannotOccurInUnicode=0xffff};

	enum {ELengthOfWorkSpace=256};

	TUint16 workSpace[ELengthOfWorkSpace];

	const TInt lengthOfUnicode=aUnicode.Length();

	TEST(lengthOfUnicode<ELengthOfWorkSpace);

	TInt i=0;

	FOREVER

		{

  		TPtr16 unicode(workSpace, 0, i);

		const TUint16* const lastCharacterOfWorkSpace=&workSpace[ELengthOfWorkSpace-1];

		{TUint16* characterPointer=&workSpace[i];

		FOREVER

			{

			*characterPointer=ECharacterCodeThatCannotOccurInUnicode;

			if (characterPointer==lastCharacterOfWorkSpace)

				{

				break;

				}

			++characterPointer;

			}}

		TInt state=CnvUtfConverter::KStateDefault;

		const TInt returnValue=(*aConvertFromUtfX)(unicode, aUtfX, state);

		TEST((returnValue!=0) || (state==CnvUtfConverter::KStateDefault));

		{const TUint16* characterPointer=&workSpace[i];

		FOREVER

			{

			TEST(*characterPointer==ECharacterCodeThatCannotOccurInUnicode);

			if (characterPointer==lastCharacterOfWorkSpace)

				{

				break;

				}

			++characterPointer;

			}}

		if (i==lengthOfUnicode)

			{

			TEST(unicode==aUnicode);

			if (returnValue!=0)

				{

				TEST(returnValue>0);

				TEST((*aConvertFromUtfX)(unicode, aUtfX.Right(returnValue), state)==0);

				TEST(unicode.Length()==0);

				TEST(state==CnvUtfConverter::KStateDefault);

				}

			break;

			}

		TEST(returnValue>0);

		++i;

		}

	}

typedef TInt (*FConvertToUtfX)(TDes8& aUtfX, const TDesC16& aUnicode);

LOCAL_C TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64(TDes8& aUtf7, const TDesC16& aUnicode)

	{

	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, ETrue);

	}

LOCAL_C TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly(TDes8& aUtf7, const TDesC16& aUnicode)

	{

	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, EFalse);

	}

LOCAL_C TInt ConvertFromUnicodeToUtf8(TDes8& aUtf8, const TDesC16& aUnicode)

	{

	return CnvUtfConverter::ConvertFromUnicodeToUtf8(aUtf8, aUnicode);

	}

LOCAL_C void ExhaustivelyLengthTest(const TDesC8& aUtfX, const TDesC16& aUnicode, FConvertToUtfX aConvertToUtfX)

	{

	enum {EByteValueThatCannotOccurInEitherUtf7OrUtf8=0xff};

	enum {ELengthOfWorkSpace=512};

	TUint8 workSpace[ELengthOfWorkSpace];

	const TInt lengthOfUtfX=aUtfX.Length();

	TEST(lengthOfUtfX<ELengthOfWorkSpace);

	TInt i=0;

	FOREVER

		{

		TPtr8 utfX(workSpace, 0, i);

		const TUint8* const lastByteOfWorkSpace=&workSpace[ELengthOfWorkSpace-1];

		{TUint8* bytePointer=&workSpace[i];

		FOREVER

			{

			*bytePointer=EByteValueThatCannotOccurInEitherUtf7OrUtf8;

			if (bytePointer==lastByteOfWorkSpace)

				{

				break;

				}

			++bytePointer;

			}}

		const TInt returnValue=(*aConvertToUtfX)(utfX, aUnicode);

		{const TUint8* bytePointer=&workSpace[i];

		FOREVER

			{

			TEST(*bytePointer==EByteValueThatCannotOccurInEitherUtf7OrUtf8);

			if (bytePointer==lastByteOfWorkSpace)

				{

				break;

				}

			++bytePointer;

			}}

		if (i==lengthOfUtfX)

			{

			TEST(returnValue==0);

			TEST(utfX==aUtfX);

			break;

			}

		TEST(returnValue>0);

		++i;

		}

	}

LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedInBase64, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedDirectly, const TDesC8& aUtf8)

	{

	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedInBase64, ConvertToUnicodeFromUtf7);

	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedDirectly, ConvertToUnicodeFromUtf7);

	ExhaustivelyLengthTest(aUnicode, aUtf8, ConvertToUnicodeFromUtf8);

	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedInBase64, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64);

	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedDirectly, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly);

	ExhaustivelyLengthTest(aUtf8, aUnicode, ConvertFromUnicodeToUtf8);

	}

LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7, const TDesC8& aUtf8)

	{

	ExhaustivelyLengthTest(aUnicode, aUtf7, aUtf7, aUtf8);

	}

LOCAL_C void ResetDescriptorsForNullTest(TDes8& aEmpty8, TDes16& aEmpty16, TDes8& aNonEmpty8, TDes16& aNonEmpty16)

	{

	aEmpty8.SetLength(0);

	aEmpty16.SetLength(0);

	aNonEmpty8=_L8("abc");

	aNonEmpty16=_L16("xyz");

	}

LOCAL_C void LengthTestGeneratingUtf7()

	{

	TBuf16<7> unicode;

	unicode.Format(_L16("+%c+&+a+"), 0x52ff);

	TPtr8 generatedUtf7(NULL, 0, 0);

	TUint8 utf7[15];

	TInt i;

	generatedUtf7.Set(utf7, 0, 15);

	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==0);

	TEST(generatedUtf7==_L8("+-+Uv8-+-&+-a+-"));

	for (i=14; i>=13; --i)

		{

		generatedUtf7.Set(utf7, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==1);

		TEST(generatedUtf7==_L8("+-+Uv8-+-&+-a"));

		}

	generatedUtf7.Set(utf7, 0, 12);

	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==2);

	TEST(generatedUtf7==_L8("+-+Uv8-+-&+-"));

	for (i=11; i>=10; --i)

		{

		generatedUtf7.Set(utf7, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==3);

		TEST(generatedUtf7==_L8("+-+Uv8-+-&"));

		}

	generatedUtf7.Set(utf7, 0, 9);

	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==4);

	TEST(generatedUtf7==_L8("+-+Uv8-+-"));

	for (i=8; i>=7; --i)

		{

		generatedUtf7.Set(utf7, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==5);

		TEST(generatedUtf7==_L8("+-+Uv8-"));

		}

	for (i=6; i>=2; --i)

		{

		generatedUtf7.Set(utf7, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==6);

		TEST(generatedUtf7==_L8("+-"));

		}

	for (i=1; i>=0; --i)

		{

		generatedUtf7.Set(utf7, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==7);

		TEST(generatedUtf7==KNullDesC8);

		}

	}

LOCAL_C void LengthTestGeneratingUtf8()

	{

	TBuf16<5> unicode;

	unicode.Format(_L16("J%c%c%c%c"), 0x027e, 0xb205, 0xdbab, 0xde4d);

	TPtr8 generatedUtf8(NULL, 0, 0);

	TUint8 utf8[10];

	TInt i;

	generatedUtf8.Set(utf8, 0, 10);

	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);

	TEST(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85\xf3\xba\xb9\x8d"));

	for (i=9; i>=6; --i)

		{

		generatedUtf8.Set(utf8, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==2);

		TEST(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85"));

		}

	for (i=5; i>=3; --i)

		{

		generatedUtf8.Set(utf8, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==3);

		TEST(generatedUtf8==_L8("J\xc9\xbe"));

		}

	for (i=2; i>=1; --i)

		{

		generatedUtf8.Set(utf8, 0, i);

		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==4);

		TEST(generatedUtf8==_L8("J"));

		}

	generatedUtf8.Set(utf8, 0, 0);

	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==5);

	TEST(generatedUtf8==KNullDesC8);

	}

/**

@SYMTestCaseID          SYSLIB-CHARCONV-CT-0569

@SYMTestCaseDesc        CnvUtfConverter class functionality test

@SYMTestPriority        Medium

@SYMTestActions        	Checking that error conditions yield appropriate error values

                        Tests exhaustively for length-testing UTF-8 2,3,4- byte Unicode character

						Tests for converting bad UTF-7 to Unicode  

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

GLDEF_C TInt DoE32MainL()

	{

	TheTest.Start(_L("Checking that error conditions yield appropriate error values"));

	ExhaustivelyLengthTest(KNullDesC16, KNullDesC8, KNullDesC8);

	ExhaustivelyLengthTest(_L16("Hello!"), _L8("Hello+ACE-"), _L8("Hello!"), _L8("Hello!"));

	HBufC * unicodeHBuf = HBufC::NewLC(32);

    TPtr16 unicode = unicodeHBuf->Des();	

    HBufC * generatedUnicodeHBuf = HBufC::NewLC(32);

    TPtr16 generatedUnicode = generatedUnicodeHBuf->Des();	

    HBufC8 * utf8HBuf = HBufC8::NewLC(64);

    TPtr8 utf8 = utf8HBuf->Des();	

    HBufC8 * generatedUtf8HBuf = HBufC8::NewLC(64);

    TPtr8 generatedUtf8 = generatedUtf8HBuf->Des();	

	const TPtrC16 percentC_16=_L16("%c");

	const TPtrC16 percentCPercentC_16=_L16("%c%c");

	const TPtrC8 percentC_8=_L8("%c");

	const TPtrC8 percentCPercentC_8=_L8("%c%c");

	const TPtrC8 percentCPercentCPercentC_8=_L8("%c%c%c");

	const TPtrC8 percentCPercentCPercentCPercentC_8=_L8("%c%c%c%c");

	TInt state=CnvUtfConverter::KStateDefault;

	//

	TheTest.Next(_L("Exhaustively length-testing a UTF-8 2-byte Unicode character"));

	unicode.Format(_L16("%c"), 0x0635);

	utf8.Format(_L8("%c%c"), 0xd8, 0xb5);

	ExhaustivelyLengthTest(unicode, _L8("+BjU-"), utf8);

	TheTest.Next(_L("Exhaustively length-testing a UTF-8 3-byte Unicode character"));

	unicode.Format(_L16("%c"), 0x679e);

	utf8.Format(_L8("%c%c%c"), 0xe6, 0x9e, 0x9e);

	ExhaustivelyLengthTest(unicode, _L8("+Z54-"), utf8);

	TheTest.Next(_L("Exhaustively length-testing a UTF-8 4-byte Unicode surrogate-pair"));

	unicode.Format(_L16("%c%c"), 0xdb0d, 0xdcab);

	utf8.Format(_L8("%c%c%c%c"), 0xf3, 0x93, 0x92, 0xab);

	ExhaustivelyLengthTest(unicode, _L8("+2w3cqw-"), utf8);

	TheTest.Next(_L("Exhaustively length-testing a UTF-7 various strings"));

	unicode.Format(_L16("a%c"), 0x0105);

	utf8.Format(_L8("a%c%c"), 0xc4, 0x85);

	ExhaustivelyLengthTest(unicode, _L8("a+AQU-"), utf8);

	unicode.Format(_L16("b%c%c"), 0x0431, 0x0431);

	utf8.Format(_L8("b%c%c%c%c"), 0xd0, 0xb1, 0xd0, 0xb1);

	ExhaustivelyLengthTest(unicode, _L8("b+BDEEMQ-"), utf8);

	unicode.Format(_L16("c%c%c%c"), 0x05e6, 0x05e6, 0x05e6);

	utf8.Format(_L8("c%c%c%c%c%c%c"), 0xd7, 0xa6, 0xd7, 0xa6, 0xd7, 0xa6);

	ExhaustivelyLengthTest(unicode, _L8("c+BeYF5gXm-"), utf8);

	unicode.Format(_L16(" %c%c%c%c"), 0xd86a, 0xdfa7, 0xd9e3, 0xde08);

	utf8.Format(_L8(" %c%c%c%c%c%c%c%c"), 0xf0, 0xaa, 0xae, 0xa7, 0xf2, 0x88, 0xb8, 0x88);

	ExhaustivelyLengthTest(unicode, _L8(" +2Grfp9nj3gg-"), utf8);

	unicode.Format(_L16("%cd"), 0x0636);

	utf8.Format(_L8("%c%cd"), 0xd8, 0xb6);

	ExhaustivelyLengthTest(unicode, _L8("+BjY-d"), utf8);

	unicode.Format(_L16("%c%ce"), 0x090f, 0x090f);

	utf8.Format(_L8("%c%c%c%c%c%ce"), 0xe0, 0xa4, 0x8f, 0xe0, 0xa4, 0x8f);

	ExhaustivelyLengthTest(unicode, _L8("+CQ8JDw-e"), utf8);

	unicode.Format(_L16("%c%c%cf"), 0x6cd5, 0x6cd5, 0x6cd5);

	utf8.Format(_L8("%c%c%c%c%c%c%c%c%cf"), 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95);

	ExhaustivelyLengthTest(unicode, _L8("+bNVs1WzV-f"), utf8);

	unicode.Format(_L16("%c%c%c%c "), 0xdbe9, 0xdcfe, 0xdb52, 0xddb4);

	utf8.Format(_L8("%c%c%c%c%c%c%c%c "), 0xf4, 0x8a, 0x93, 0xbe, 0xf3, 0xa4, 0xa6, 0xb4);

	ExhaustivelyLengthTest(unicode, _L8("+2+nc/ttS3bQ- "), utf8);

	TheTest.Next(_L("Converting to short UTF-7 descriptors"));

	LengthTestGeneratingUtf7();

	TheTest.Next(_L("Converting to short UTF-8 descriptors"));

	LengthTestGeneratingUtf8();

	{

	TheTest.Next(_L("Testing converting bad UTF-7 to Unicode"));

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8(")+"), state)==1);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==')');

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+ "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+>"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode==_L16("+"));

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A"), state)==0);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A "), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode==_L16(" "));

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B"), state)==1);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA"), state)==0);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA "), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode==_L16(" "));

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB"), state)==2);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA"), state)==2);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB"), state)==2);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY"), state)==0);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY "), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==2);

	TEST(generatedUnicode[0]==0xb676);

	TEST(generatedUnicode[1]==0x0020);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ"), state)==3);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna"), state)==3);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb"), state)==3);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==0);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA"), state)==0);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA "), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==2);

	TEST(generatedUnicode[0]==0xb676);

	TEST(generatedUnicode[1]==0x0020);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB"), state)==1);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA"), state)==1);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB"), state)==1);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB "), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB-"), state)==CnvUtfConverter::EErrorIllFormedInput);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA"), state)==0);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA "), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==2);

	TEST(generatedUnicode[0]==0xb676);

	TEST(generatedUnicode[1]==0x0020);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA-"), state)==0);

	TEST(state==CnvUtfConverter::KStateDefault);

	TEST(generatedUnicode.Length()==1);

	TEST(generatedUnicode[0]==0xb676);

	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB"), state)==2);

	TEST(state!=CnvUtfConverter::KStateDefault);

	state=CnvUtfConverter::KStateDefault;