Mercurial Mercurial > oss > FCL > sf > os > textandloc / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
charconvfw/charconv_fw/test/rtest/tsrc/utf/terror.cpp
changeset 51 a7c938434754
parent 0 1fb32624e06b
child 55 336bee5c2d35
equal deleted inserted replaced
44:601ab138ba0b 51:a7c938434754 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 
    18 
    19 #include <e32std.h>
 
    19 #include <e32std.h>
 
    20 #include <e32test.h>
 
       
    21 #include <utf.h>
 
    20 #include <utf.h>
 
    22 
    21 #include "t_error.h"
 
    23 ///////////////////////////////////////////////////////////////////////////////////////
 
    22 
    24 
    23 #define test(cond)                                          \
 
    25 RTest TheTest(_L("TError"));
 
    24     {                                                       \
 
       
    25     TBool __bb = (cond);                                    \
 
       
    26     TEST(__bb);                                             \
 
       
    27     if (!__bb)                                              \
 
       
    28         {                                                   \
 
       
    29         ERR_PRINTF1(_L("ERROR: Test Failed"));              \
 
       
    30         User::Leave(1);                                     \
 
       
    31         }                                                   \
 
       
    32     }
 
       
    33 
    26 
    34 
    27 ///////////////////////////////////////////////////////////////////////////////////////
 
    35 ///////////////////////////////////////////////////////////////////////////////////////
 
    28 ///////////////////////////////////////////////////////////////////////////////////////
 
    36 ///////////////////////////////////////////////////////////////////////////////////////
 
    29 //Tests macroses and functions.
 
    37 
    30 //If (!aValue) then the test will be panicked, the test data files will be deleted.
 
    38 //typedef TInt (*FConvertFromUtfX)(TDes16& aUnicode, const TDesC8& aUtfX, TInt& aState);
 
    31 static void Check(TInt aValue, TInt aLine)
 
    39 
    32 	{
 
    40 TInt ConvertToUnicodeFromUtf7(TDes16& aUnicode, const TDesC8& aUtf7, TInt& aState)
 
    33 	if(!aValue)
 
       
    34 		{
 
       
    35 		TheTest(EFalse, aLine);
 
       
    36 		}
 
       
    37 	}
 
       
    38 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
 
       
    39 static void Check(TInt aValue, TInt aExpected, TInt aLine)
 
       
    40 	{
 
       
    41 	if(aValue != aExpected)
 
       
    42 		{
 
       
    43 		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 
       
    44 		TheTest(EFalse, aLine);
 
       
    45 		}
 
       
    46 	}
 
       
    47 //Use these to test conditions.
 
       
    48 #define TEST(arg) ::Check((arg), __LINE__)
 
       
    49 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
 
       
    50 
       
    51 ///////////////////////////////////////////////////////////////////////////////////////
 
       
    52 ///////////////////////////////////////////////////////////////////////////////////////
 
       
    53 
       
    54 typedef TInt (*FConvertFromUtfX)(TDes16& aUnicode, const TDesC8& aUtfX, TInt& aState);
 
       
    55 
       
    56 LOCAL_C TInt ConvertToUnicodeFromUtf7(TDes16& aUnicode, const TDesC8& aUtf7, TInt& aState)
 
       
    57 	{
 
    41 	{
 
    58 	return CnvUtfConverter::ConvertToUnicodeFromUtf7(aUnicode, aUtf7, aState);
 
    42 	return CnvUtfConverter::ConvertToUnicodeFromUtf7(aUnicode, aUtf7, aState);
 
    59 	}
 
    43 	}
 
    60 
    44 
    61 LOCAL_C TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, TInt&)
 
    45 TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, TInt&)
 
    62 	{
 
    46 	{
 
    63 	return CnvUtfConverter::ConvertToUnicodeFromUtf8(aUnicode, aUtf8);
 
    47 	return CnvUtfConverter::ConvertToUnicodeFromUtf8(aUnicode, aUtf8);
 
    64 	}
 
    48 	}
 
    65 
    49 
    66 LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtfX, FConvertFromUtfX aConvertFromUtfX)
 
    50 void CT_ERROR::ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtfX, FConvertFromUtfX aConvertFromUtfX)
 
    67 	{
 
    51 	{
 
    68 	enum {ECharacterCodeThatCannotOccurInUnicode=0xffff};
 
    52 	enum {ECharacterCodeThatCannotOccurInUnicode=0xffff};
 
    69 	enum {ELengthOfWorkSpace=256};
 
    53 	enum {ELengthOfWorkSpace=256};
 
    70 
    54 
    71 	TUint16 workSpace[ELengthOfWorkSpace];
 
    55 	TUint16 workSpace[ELengthOfWorkSpace];
 
    72 
    56 
    73 	const TInt lengthOfUnicode=aUnicode.Length();
 
    57 	const TInt lengthOfUnicode=aUnicode.Length();
 
    74 	TEST(lengthOfUnicode<ELengthOfWorkSpace);
 
    58 	test(lengthOfUnicode<ELengthOfWorkSpace);
 
    75 	TInt i=0;
 
    59 	TInt i=0;
 
    76 	FOREVER
 
    60 	FOREVER
 
    77 		{
 
    61 		{
 
    78   		TPtr16 unicode(workSpace, 0, i);
 
    62   		TPtr16 unicode(workSpace, 0, i);
 
    79 
    63 
    90 			++characterPointer;
 
    74 			++characterPointer;
 
    91 			}}
 
    75 			}}
 
    92 		TInt state=CnvUtfConverter::KStateDefault;
 
    76 		TInt state=CnvUtfConverter::KStateDefault;
 
    93 
    77 
    94 		const TInt returnValue=(*aConvertFromUtfX)(unicode, aUtfX, state);
 
    78 		const TInt returnValue=(*aConvertFromUtfX)(unicode, aUtfX, state);
 
    95 		TEST((returnValue!=0) || (state==CnvUtfConverter::KStateDefault));
 
    79 		test((returnValue!=0) || (state==CnvUtfConverter::KStateDefault));
 
    96 		{const TUint16* characterPointer=&workSpace[i];
 
    80 		{const TUint16* characterPointer=&workSpace[i];
 
    97 		FOREVER
 
    81 		FOREVER
 
    98 			{
 
    82 			{
 
    99 			TEST(*characterPointer==ECharacterCodeThatCannotOccurInUnicode);
 
    83 			test(*characterPointer==ECharacterCodeThatCannotOccurInUnicode);
 
   100 			if (characterPointer==lastCharacterOfWorkSpace)
 
    84 			if (characterPointer==lastCharacterOfWorkSpace)
 
   101 				{
 
    85 				{
 
   102 				break;
 
    86 				break;
 
   103 				}
 
    87 				}
 
   104 			++characterPointer;
 
    88 			++characterPointer;
 
   105 			}}
 
    89 			}}
 
   106 		if (i==lengthOfUnicode)
 
    90 		if (i==lengthOfUnicode)
 
   107 			{
 
    91 			{
 
   108 			TEST(unicode==aUnicode);
 
    92 			test(unicode==aUnicode);
 
   109 			if (returnValue!=0)
 
    93 			if (returnValue!=0)
 
   110 				{
 
    94 				{
 
   111 				TEST(returnValue>0);
 
    95 				test(returnValue>0);
 
   112 				TEST((*aConvertFromUtfX)(unicode, aUtfX.Right(returnValue), state)==0);
 
    96 				test((*aConvertFromUtfX)(unicode, aUtfX.Right(returnValue), state)==0);
 
   113 				TEST(unicode.Length()==0);
 
    97 				test(unicode.Length()==0);
 
   114 				TEST(state==CnvUtfConverter::KStateDefault);
 
    98 				test(state==CnvUtfConverter::KStateDefault);
 
   115 				}
 
    99 				}
 
   116 			break;
 
   100 			break;
 
   117 			}
 
   101 			}
 
   118 		TEST(returnValue>0);
 
   102 		test(returnValue>0);
 
   119 		++i;
 
   103 		++i;
 
   120 		}
 
   104 		}
 
   121 	}
 
   105 	}
 
   122 
   106 
   123 typedef TInt (*FConvertToUtfX)(TDes8& aUtfX, const TDesC16& aUnicode);
 
   107 //typedef TInt (*FConvertToUtfX)(TDes8& aUtfX, const TDesC16& aUnicode);
 
   124 
   108 
   125 LOCAL_C TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64(TDes8& aUtf7, const TDesC16& aUnicode)
 
   109 TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64(TDes8& aUtf7, const TDesC16& aUnicode)
 
   126 	{
 
   110 	{
 
   127 	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, ETrue);
 
   111 	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, ETrue);
 
   128 	}
 
   112 	}
 
   129 
   113 
   130 LOCAL_C TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly(TDes8& aUtf7, const TDesC16& aUnicode)
 
   114 TInt ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly(TDes8& aUtf7, const TDesC16& aUnicode)
 
   131 	{
 
   115 	{
 
   132 	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, EFalse);
 
   116 	return CnvUtfConverter::ConvertFromUnicodeToUtf7(aUtf7, aUnicode, EFalse);
 
   133 	}
 
   117 	}
 
   134 
   118 
   135 LOCAL_C TInt ConvertFromUnicodeToUtf8(TDes8& aUtf8, const TDesC16& aUnicode)
 
   119 TInt ConvertFromUnicodeToUtf8(TDes8& aUtf8, const TDesC16& aUnicode)
 
   136 	{
 
   120 	{
 
   137 	return CnvUtfConverter::ConvertFromUnicodeToUtf8(aUtf8, aUnicode);
 
   121 	return CnvUtfConverter::ConvertFromUnicodeToUtf8(aUtf8, aUnicode);
 
   138 	}
 
   122 	}
 
   139 
   123 
   140 LOCAL_C void ExhaustivelyLengthTest(const TDesC8& aUtfX, const TDesC16& aUnicode, FConvertToUtfX aConvertToUtfX)
 
   124 void CT_ERROR::ExhaustivelyLengthTest(const TDesC8& aUtfX, const TDesC16& aUnicode, FConvertToUtfX aConvertToUtfX)
 
   141 	{
 
   125 	{
 
   142 	enum {EByteValueThatCannotOccurInEitherUtf7OrUtf8=0xff};
 
   126 	enum {EByteValueThatCannotOccurInEitherUtf7OrUtf8=0xff};
 
   143 	enum {ELengthOfWorkSpace=512};
 
   127 	enum {ELengthOfWorkSpace=512};
 
   144 	TUint8 workSpace[ELengthOfWorkSpace];
 
   128 	TUint8 workSpace[ELengthOfWorkSpace];
 
   145 	const TInt lengthOfUtfX=aUtfX.Length();
 
   129 	const TInt lengthOfUtfX=aUtfX.Length();
 
   146 	TEST(lengthOfUtfX<ELengthOfWorkSpace);
 
   130 	test(lengthOfUtfX<ELengthOfWorkSpace);
 
   147 	TInt i=0;
 
   131 	TInt i=0;
 
   148 	FOREVER
 
   132 	FOREVER
 
   149 		{
 
   133 		{
 
   150 		TPtr8 utfX(workSpace, 0, i);
 
   134 		TPtr8 utfX(workSpace, 0, i);
 
   151 		const TUint8* const lastByteOfWorkSpace=&workSpace[ELengthOfWorkSpace-1];
 
   135 		const TUint8* const lastByteOfWorkSpace=&workSpace[ELengthOfWorkSpace-1];
 
   161 			}}
 
   145 			}}
 
   162 		const TInt returnValue=(*aConvertToUtfX)(utfX, aUnicode);
 
   146 		const TInt returnValue=(*aConvertToUtfX)(utfX, aUnicode);
 
   163 		{const TUint8* bytePointer=&workSpace[i];
 
   147 		{const TUint8* bytePointer=&workSpace[i];
 
   164 		FOREVER
 
   148 		FOREVER
 
   165 			{
 
   149 			{
 
   166 			TEST(*bytePointer==EByteValueThatCannotOccurInEitherUtf7OrUtf8);
 
   150 			test(*bytePointer==EByteValueThatCannotOccurInEitherUtf7OrUtf8);
 
   167 			if (bytePointer==lastByteOfWorkSpace)
 
   151 			if (bytePointer==lastByteOfWorkSpace)
 
   168 				{
 
   152 				{
 
   169 				break;
 
   153 				break;
 
   170 				}
 
   154 				}
 
   171 			++bytePointer;
 
   155 			++bytePointer;
 
   172 			}}
 
   156 			}}
 
   173 		if (i==lengthOfUtfX)
 
   157 		if (i==lengthOfUtfX)
 
   174 			{
 
   158 			{
 
   175 			TEST(returnValue==0);
 
   159 			test(returnValue==0);
 
   176 			TEST(utfX==aUtfX);
 
   160 			test(utfX==aUtfX);
 
   177 			break;
 
   161 			break;
 
   178 			}
 
   162 			}
 
   179 		TEST(returnValue>0);
 
   163 		test(returnValue>0);
 
   180 		++i;
 
   164 		++i;
 
   181 		}
 
   165 		}
 
   182 	}
 
   166 	}
 
   183 
   167 
   184 LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedInBase64, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedDirectly, const TDesC8& aUtf8)
 
   168 void CT_ERROR::ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedInBase64, const TDesC8& aUtf7WithOptionalDirectCharactersEncodedDirectly, const TDesC8& aUtf8)
 
   185 	{
 
   169 	{
 
   186 	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedInBase64, ConvertToUnicodeFromUtf7);
 
   170 	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedInBase64, ConvertToUnicodeFromUtf7);
 
   187 	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedDirectly, ConvertToUnicodeFromUtf7);
 
   171 	ExhaustivelyLengthTest(aUnicode, aUtf7WithOptionalDirectCharactersEncodedDirectly, ConvertToUnicodeFromUtf7);
 
   188 	ExhaustivelyLengthTest(aUnicode, aUtf8, ConvertToUnicodeFromUtf8);
 
   172 	ExhaustivelyLengthTest(aUnicode, aUtf8, ConvertToUnicodeFromUtf8);
 
   189 	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedInBase64, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64);
 
   173 	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedInBase64, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedInBase64);
 
   190 	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedDirectly, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly);
 
   174 	ExhaustivelyLengthTest(aUtf7WithOptionalDirectCharactersEncodedDirectly, aUnicode, ConvertFromUnicodeToUtf7WithOptionalDirectCharactersEncodedDirectly);
 
   191 	ExhaustivelyLengthTest(aUtf8, aUnicode, ConvertFromUnicodeToUtf8);
 
   175 	ExhaustivelyLengthTest(aUtf8, aUnicode, ConvertFromUnicodeToUtf8);
 
   192 	}
 
   176 	}
 
   193 
   177 
   194 LOCAL_C void ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7, const TDesC8& aUtf8)
 
   178 void CT_ERROR::ExhaustivelyLengthTest(const TDesC16& aUnicode, const TDesC8& aUtf7, const TDesC8& aUtf8)
 
   195 	{
 
   179 	{
 
   196 	ExhaustivelyLengthTest(aUnicode, aUtf7, aUtf7, aUtf8);
 
   180 	ExhaustivelyLengthTest(aUnicode, aUtf7, aUtf7, aUtf8);
 
   197 	}
 
   181 	}
 
   198 
   182 
   199 LOCAL_C void ResetDescriptorsForNullTest(TDes8& aEmpty8, TDes16& aEmpty16, TDes8& aNonEmpty8, TDes16& aNonEmpty16)
 
   183 void ResetDescriptorsForNullTest(TDes8& aEmpty8, TDes16& aEmpty16, TDes8& aNonEmpty8, TDes16& aNonEmpty16)
 
   200 	{
 
   184 	{
 
   201 	aEmpty8.SetLength(0);
 
   185 	aEmpty8.SetLength(0);
 
   202 	aEmpty16.SetLength(0);
 
   186 	aEmpty16.SetLength(0);
 
   203 	aNonEmpty8=_L8("abc");
 
   187 	aNonEmpty8=_L8("abc");
 
   204 	aNonEmpty16=_L16("xyz");
 
   188 	aNonEmpty16=_L16("xyz");
 
   205 	}
 
   189 	}
 
   206 
   190 
   207 LOCAL_C void LengthTestGeneratingUtf7()
 
   191 void CT_ERROR::LengthTestGeneratingUtf7()
 
   208 	{
 
   192 	{
 
   209 	TBuf16<7> unicode;
 
   193 	TBuf16<7> unicode;
 
   210 	unicode.Format(_L16("+%c+&+a+"), 0x52ff);
 
   194 	unicode.Format(_L16("+%c+&+a+"), 0x52ff);
 
   211 	TPtr8 generatedUtf7(NULL, 0, 0);
 
   195 	TPtr8 generatedUtf7(NULL, 0, 0);
 
   212 	TUint8 utf7[15];
 
   196 	TUint8 utf7[15];
 
   213 	TInt i;
 
   197 	TInt i;
 
   214 	generatedUtf7.Set(utf7, 0, 15);
 
   198 	generatedUtf7.Set(utf7, 0, 15);
 
   215 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==0);
 
   199 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==0);
 
   216 	TEST(generatedUtf7==_L8("+-+Uv8-+-&+-a+-"));
 
   200 	test(generatedUtf7==_L8("+-+Uv8-+-&+-a+-"));
 
   217 	for (i=14; i>=13; --i)
 
   201 	for (i=14; i>=13; --i)
 
   218 		{
 
   202 		{
 
   219 		generatedUtf7.Set(utf7, 0, i);
 
   203 		generatedUtf7.Set(utf7, 0, i);
 
   220 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==1);
 
   204 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==1);
 
   221 		TEST(generatedUtf7==_L8("+-+Uv8-+-&+-a"));
 
   205 		test(generatedUtf7==_L8("+-+Uv8-+-&+-a"));
 
   222 		}
 
   206 		}
 
   223 	generatedUtf7.Set(utf7, 0, 12);
 
   207 	generatedUtf7.Set(utf7, 0, 12);
 
   224 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==2);
 
   208 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==2);
 
   225 	TEST(generatedUtf7==_L8("+-+Uv8-+-&+-"));
 
   209 	test(generatedUtf7==_L8("+-+Uv8-+-&+-"));
 
   226 	for (i=11; i>=10; --i)
 
   210 	for (i=11; i>=10; --i)
 
   227 		{
 
   211 		{
 
   228 		generatedUtf7.Set(utf7, 0, i);
 
   212 		generatedUtf7.Set(utf7, 0, i);
 
   229 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==3);
 
   213 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==3);
 
   230 		TEST(generatedUtf7==_L8("+-+Uv8-+-&"));
 
   214 		test(generatedUtf7==_L8("+-+Uv8-+-&"));
 
   231 		}
 
   215 		}
 
   232 	generatedUtf7.Set(utf7, 0, 9);
 
   216 	generatedUtf7.Set(utf7, 0, 9);
 
   233 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==4);
 
   217 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==4);
 
   234 	TEST(generatedUtf7==_L8("+-+Uv8-+-"));
 
   218 	test(generatedUtf7==_L8("+-+Uv8-+-"));
 
   235 	for (i=8; i>=7; --i)
 
   219 	for (i=8; i>=7; --i)
 
   236 		{
 
   220 		{
 
   237 		generatedUtf7.Set(utf7, 0, i);
 
   221 		generatedUtf7.Set(utf7, 0, i);
 
   238 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==5);
 
   222 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==5);
 
   239 		TEST(generatedUtf7==_L8("+-+Uv8-"));
 
   223 		test(generatedUtf7==_L8("+-+Uv8-"));
 
   240 		}
 
   224 		}
 
   241 	for (i=6; i>=2; --i)
 
   225 	for (i=6; i>=2; --i)
 
   242 		{
 
   226 		{
 
   243 		generatedUtf7.Set(utf7, 0, i);
 
   227 		generatedUtf7.Set(utf7, 0, i);
 
   244 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==6);
 
   228 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==6);
 
   245 		TEST(generatedUtf7==_L8("+-"));
 
   229 		test(generatedUtf7==_L8("+-"));
 
   246 		}
 
   230 		}
 
   247 	for (i=1; i>=0; --i)
 
   231 	for (i=1; i>=0; --i)
 
   248 		{
 
   232 		{
 
   249 		generatedUtf7.Set(utf7, 0, i);
 
   233 		generatedUtf7.Set(utf7, 0, i);
 
   250 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==7);
 
   234 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf7, unicode, EFalse)==7);
 
   251 		TEST(generatedUtf7==KNullDesC8);
 
   235 		test(generatedUtf7==KNullDesC8);
 
   252 		}
 
   236 		}
 
   253 	}
 
   237 	}
 
   254 
   238 
   255 LOCAL_C void LengthTestGeneratingUtf8()
 
   239 void CT_ERROR::LengthTestGeneratingUtf8()
 
   256 	{
 
   240 	{
 
   257 	TBuf16<5> unicode;
 
   241 	TBuf16<5> unicode;
 
   258 	unicode.Format(_L16("J%c%c%c%c"), 0x027e, 0xb205, 0xdbab, 0xde4d);
 
   242 	unicode.Format(_L16("J%c%c%c%c"), 0x027e, 0xb205, 0xdbab, 0xde4d);
 
   259 	TPtr8 generatedUtf8(NULL, 0, 0);
 
   243 	TPtr8 generatedUtf8(NULL, 0, 0);
 
   260 	TUint8 utf8[10];
 
   244 	TUint8 utf8[10];
 
   261 	TInt i;
 
   245 	TInt i;
 
   262 	generatedUtf8.Set(utf8, 0, 10);
 
   246 	generatedUtf8.Set(utf8, 0, 10);
 
   263 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   247 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   264 	TEST(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85\xf3\xba\xb9\x8d"));
 
   248 	test(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85\xf3\xba\xb9\x8d"));
 
   265 	for (i=9; i>=6; --i)
 
   249 	for (i=9; i>=6; --i)
 
   266 		{
 
   250 		{
 
   267 		generatedUtf8.Set(utf8, 0, i);
 
   251 		generatedUtf8.Set(utf8, 0, i);
 
   268 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==2);
 
   252 		test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==2);
 
   269 		TEST(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85"));
 
   253 		test(generatedUtf8==_L8("J\xc9\xbe\xeb\x88\x85"));
 
   270 		}
 
   254 		}
 
   271 	for (i=5; i>=3; --i)
 
   255 	for (i=5; i>=3; --i)
 
   272 		{
 
   256 		{
 
   273 		generatedUtf8.Set(utf8, 0, i);
 
   257 		generatedUtf8.Set(utf8, 0, i);
 
   274 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==3);
 
   258 		test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==3);
 
   275 		TEST(generatedUtf8==_L8("J\xc9\xbe"));
 
   259 		test(generatedUtf8==_L8("J\xc9\xbe"));
 
   276 		}
 
   260 		}
 
   277 	for (i=2; i>=1; --i)
 
   261 	for (i=2; i>=1; --i)
 
   278 		{
 
   262 		{
 
   279 		generatedUtf8.Set(utf8, 0, i);
 
   263 		generatedUtf8.Set(utf8, 0, i);
 
   280 		TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==4);
 
   264 		test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==4);
 
   281 		TEST(generatedUtf8==_L8("J"));
 
   265 		test(generatedUtf8==_L8("J"));
 
   282 		}
 
   266 		}
 
   283 	generatedUtf8.Set(utf8, 0, 0);
 
   267 	generatedUtf8.Set(utf8, 0, 0);
 
   284 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==5);
 
   268 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==5);
 
   285 	TEST(generatedUtf8==KNullDesC8);
 
   269 	test(generatedUtf8==KNullDesC8);
 
   286 	}
 
   270 	}
 
   287 /**
 
   271 /**
 
   288 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0569
 
   272 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0569
 
   289 @SYMTestCaseDesc        CnvUtfConverter class functionality test
 
   273 @SYMTestCaseDesc        CnvUtfConverter class functionality test
 
   290 @SYMTestPriority        Medium
 
   274 @SYMTestPriority        Medium
 
   292                         Tests exhaustively for length-testing UTF-8 2,3,4- byte Unicode character
 
   276                         Tests exhaustively for length-testing UTF-8 2,3,4- byte Unicode character
 
   293 						Tests for converting bad UTF-7 to Unicode
 
   277 						Tests for converting bad UTF-7 to Unicode
 
   294 @SYMTestExpectedResults Test must not fail
 
   278 @SYMTestExpectedResults Test must not fail
 
   295 @SYMREQ                 REQ0000
 
   279 @SYMREQ                 REQ0000
 
   296 */
 
   280 */
 
   297 GLDEF_C TInt DoE32MainL()
 
   281 void CT_ERROR::TestERROR()
 
   298 	{
 
   282 	{
 
   299 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0569 Checking that error conditions yield appropriate error values "));
 
   283     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0569 Checking that error conditions yield appropriate error values "));
 
   300 	ExhaustivelyLengthTest(KNullDesC16, KNullDesC8, KNullDesC8);
 
   284 	ExhaustivelyLengthTest(KNullDesC16, KNullDesC8, KNullDesC8);
 
   301 	ExhaustivelyLengthTest(_L16("Hello!"), _L8("Hello+ACE-"), _L8("Hello!"), _L8("Hello!"));
 
   285 	ExhaustivelyLengthTest(_L16("Hello!"), _L8("Hello+ACE-"), _L8("Hello!"), _L8("Hello!"));
 
   302 
   286 
   303 	HBufC * unicodeHBuf = HBufC::NewLC(32);
 
   287 	HBufC * unicodeHBuf = HBufC::NewLC(32);
 
   304     TPtr16 unicode = unicodeHBuf->Des();
 
   288     TPtr16 unicode = unicodeHBuf->Des();
 
   315 	const TPtrC8 percentCPercentC_8=_L8("%c%c");
 
   299 	const TPtrC8 percentCPercentC_8=_L8("%c%c");
 
   316 	const TPtrC8 percentCPercentCPercentC_8=_L8("%c%c%c");
 
   300 	const TPtrC8 percentCPercentCPercentC_8=_L8("%c%c%c");
 
   317 	const TPtrC8 percentCPercentCPercentCPercentC_8=_L8("%c%c%c%c");
 
   301 	const TPtrC8 percentCPercentCPercentCPercentC_8=_L8("%c%c%c%c");
 
   318 	TInt state=CnvUtfConverter::KStateDefault;
 
   302 	TInt state=CnvUtfConverter::KStateDefault;
 
   319 	//
 
   303 	//
 
   320 	TheTest.Next(_L("Exhaustively length-testing a UTF-8 2-byte Unicode character"));
 
   304 	INFO_PRINTF1(_L("Exhaustively length-testing a UTF-8 2-byte Unicode character"));
 
   321 	unicode.Format(_L16("%c"), 0x0635);
 
   305 	unicode.Format(_L16("%c"), 0x0635);
 
   322 	utf8.Format(_L8("%c%c"), 0xd8, 0xb5);
 
   306 	utf8.Format(_L8("%c%c"), 0xd8, 0xb5);
 
   323 	ExhaustivelyLengthTest(unicode, _L8("+BjU-"), utf8);
 
   307 	ExhaustivelyLengthTest(unicode, _L8("+BjU-"), utf8);
 
   324 	TheTest.Next(_L("Exhaustively length-testing a UTF-8 3-byte Unicode character"));
 
   308 	INFO_PRINTF1(_L("Exhaustively length-testing a UTF-8 3-byte Unicode character"));
 
   325 	unicode.Format(_L16("%c"), 0x679e);
 
   309 	unicode.Format(_L16("%c"), 0x679e);
 
   326 	utf8.Format(_L8("%c%c%c"), 0xe6, 0x9e, 0x9e);
 
   310 	utf8.Format(_L8("%c%c%c"), 0xe6, 0x9e, 0x9e);
 
   327 	ExhaustivelyLengthTest(unicode, _L8("+Z54-"), utf8);
 
   311 	ExhaustivelyLengthTest(unicode, _L8("+Z54-"), utf8);
 
   328 	TheTest.Next(_L("Exhaustively length-testing a UTF-8 4-byte Unicode surrogate-pair"));
 
   312 	INFO_PRINTF1(_L("Exhaustively length-testing a UTF-8 4-byte Unicode surrogate-pair"));
 
   329 	unicode.Format(_L16("%c%c"), 0xdb0d, 0xdcab);
 
   313 	unicode.Format(_L16("%c%c"), 0xdb0d, 0xdcab);
 
   330 	utf8.Format(_L8("%c%c%c%c"), 0xf3, 0x93, 0x92, 0xab);
 
   314 	utf8.Format(_L8("%c%c%c%c"), 0xf3, 0x93, 0x92, 0xab);
 
   331 	ExhaustivelyLengthTest(unicode, _L8("+2w3cqw-"), utf8);
 
   315 	ExhaustivelyLengthTest(unicode, _L8("+2w3cqw-"), utf8);
 
   332 	TheTest.Next(_L("Exhaustively length-testing a UTF-7 various strings"));
 
   316 	INFO_PRINTF1(_L("Exhaustively length-testing a UTF-7 various strings"));
 
   333 	unicode.Format(_L16("a%c"), 0x0105);
 
   317 	unicode.Format(_L16("a%c"), 0x0105);
 
   334 	utf8.Format(_L8("a%c%c"), 0xc4, 0x85);
 
   318 	utf8.Format(_L8("a%c%c"), 0xc4, 0x85);
 
   335 	ExhaustivelyLengthTest(unicode, _L8("a+AQU-"), utf8);
 
   319 	ExhaustivelyLengthTest(unicode, _L8("a+AQU-"), utf8);
 
   336 	unicode.Format(_L16("b%c%c"), 0x0431, 0x0431);
 
   320 	unicode.Format(_L16("b%c%c"), 0x0431, 0x0431);
 
   337 	utf8.Format(_L8("b%c%c%c%c"), 0xd0, 0xb1, 0xd0, 0xb1);
 
   321 	utf8.Format(_L8("b%c%c%c%c"), 0xd0, 0xb1, 0xd0, 0xb1);
 
   352 	utf8.Format(_L8("%c%c%c%c%c%c%c%c%cf"), 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95);
 
   336 	utf8.Format(_L8("%c%c%c%c%c%c%c%c%cf"), 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95, 0xe6, 0xb3, 0x95);
 
   353 	ExhaustivelyLengthTest(unicode, _L8("+bNVs1WzV-f"), utf8);
 
   337 	ExhaustivelyLengthTest(unicode, _L8("+bNVs1WzV-f"), utf8);
 
   354 	unicode.Format(_L16("%c%c%c%c "), 0xdbe9, 0xdcfe, 0xdb52, 0xddb4);
 
   338 	unicode.Format(_L16("%c%c%c%c "), 0xdbe9, 0xdcfe, 0xdb52, 0xddb4);
 
   355 	utf8.Format(_L8("%c%c%c%c%c%c%c%c "), 0xf4, 0x8a, 0x93, 0xbe, 0xf3, 0xa4, 0xa6, 0xb4);
 
   339 	utf8.Format(_L8("%c%c%c%c%c%c%c%c "), 0xf4, 0x8a, 0x93, 0xbe, 0xf3, 0xa4, 0xa6, 0xb4);
 
   356 	ExhaustivelyLengthTest(unicode, _L8("+2+nc/ttS3bQ- "), utf8);
 
   340 	ExhaustivelyLengthTest(unicode, _L8("+2+nc/ttS3bQ- "), utf8);
 
   357 	TheTest.Next(_L("Converting to short UTF-7 descriptors"));
 
   341 	INFO_PRINTF1(_L("Converting to short UTF-7 descriptors"));
 
   358 	LengthTestGeneratingUtf7();
 
   342 	LengthTestGeneratingUtf7();
 
   359 	TheTest.Next(_L("Converting to short UTF-8 descriptors"));
 
   343 	INFO_PRINTF1(_L("Converting to short UTF-8 descriptors"));
 
   360 	LengthTestGeneratingUtf8();
 
   344 	LengthTestGeneratingUtf8();
 
   361 	{
 
   345 	{
 
   362 	TheTest.Next(_L("Testing converting bad UTF-7 to Unicode"));
 
   346 	INFO_PRINTF1(_L("Testing converting bad UTF-7 to Unicode"));
 
   363 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   347 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   364 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8(")+"), state)==1);
 
   348 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8(")+"), state)==1);
 
   365 	TEST(state==CnvUtfConverter::KStateDefault);
 
   349 	test(state==CnvUtfConverter::KStateDefault);
 
   366 	TEST(generatedUnicode.Length()==1);
 
   350 	test(generatedUnicode.Length()==1);
 
   367 	TEST(generatedUnicode[0]==')');
 
   351 	test(generatedUnicode[0]==')');
 
   368 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+ "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   352 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+ "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   369 	TEST(state==CnvUtfConverter::KStateDefault);
 
   353 	test(state==CnvUtfConverter::KStateDefault);
 
   370 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+>"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   354 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+>"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   371 	TEST(state==CnvUtfConverter::KStateDefault);
 
   355 	test(state==CnvUtfConverter::KStateDefault);
 
   372 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+-"), state)==0);
 
   356 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+-"), state)==0);
 
   373 	TEST(state==CnvUtfConverter::KStateDefault);
 
   357 	test(state==CnvUtfConverter::KStateDefault);
 
   374 	TEST(generatedUnicode==_L16("+"));
 
   358 	test(generatedUnicode==_L16("+"));
 
   375 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A"), state)==0);
 
   359 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A"), state)==0);
 
   376 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   360 	test(state!=CnvUtfConverter::KStateDefault);
 
   377 	state=CnvUtfConverter::KStateDefault;
 
   361 	state=CnvUtfConverter::KStateDefault;
 
   378 	TEST(generatedUnicode.Length()==0);
 
   362 	test(generatedUnicode.Length()==0);
 
   379 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A "), state)==0);
 
   363 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A "), state)==0);
 
   380 	TEST(state==CnvUtfConverter::KStateDefault);
 
   364 	test(state==CnvUtfConverter::KStateDefault);
 
   381 	TEST(generatedUnicode==_L16(" "));
 
   365 	test(generatedUnicode==_L16(" "));
 
   382 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A-"), state)==0);
 
   366 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+A-"), state)==0);
 
   383 	TEST(state==CnvUtfConverter::KStateDefault);
 
   367 	test(state==CnvUtfConverter::KStateDefault);
 
   384 	TEST(generatedUnicode.Length()==0);
 
   368 	test(generatedUnicode.Length()==0);
 
   385 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B"), state)==1);
 
   369 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B"), state)==1);
 
   386 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   370 	test(state!=CnvUtfConverter::KStateDefault);
 
   387 	state=CnvUtfConverter::KStateDefault;
 
   371 	state=CnvUtfConverter::KStateDefault;
 
   388 	TEST(generatedUnicode.Length()==0);
 
   372 	test(generatedUnicode.Length()==0);
 
   389 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   373 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   390 	TEST(state==CnvUtfConverter::KStateDefault);
 
   374 	test(state==CnvUtfConverter::KStateDefault);
 
   391 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   375 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+B-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   392 	TEST(state==CnvUtfConverter::KStateDefault);
 
   376 	test(state==CnvUtfConverter::KStateDefault);
 
   393 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA"), state)==0);
 
   377 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA"), state)==0);
 
   394 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   378 	test(state!=CnvUtfConverter::KStateDefault);
 
   395 	state=CnvUtfConverter::KStateDefault;
 
   379 	state=CnvUtfConverter::KStateDefault;
 
   396 	TEST(generatedUnicode.Length()==0);
 
   380 	test(generatedUnicode.Length()==0);
 
   397 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA "), state)==0);
 
   381 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA "), state)==0);
 
   398 	TEST(state==CnvUtfConverter::KStateDefault);
 
   382 	test(state==CnvUtfConverter::KStateDefault);
 
   399 	TEST(generatedUnicode==_L16(" "));
 
   383 	test(generatedUnicode==_L16(" "));
 
   400 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA-"), state)==0);
 
   384 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AA-"), state)==0);
 
   401 	TEST(state==CnvUtfConverter::KStateDefault);
 
   385 	test(state==CnvUtfConverter::KStateDefault);
 
   402 	TEST(generatedUnicode.Length()==0);
 
   386 	test(generatedUnicode.Length()==0);
 
   403 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB"), state)==2);
 
   387 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB"), state)==2);
 
   404 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   388 	test(state!=CnvUtfConverter::KStateDefault);
 
   405 	state=CnvUtfConverter::KStateDefault;
 
   389 	state=CnvUtfConverter::KStateDefault;
 
   406 	TEST(generatedUnicode.Length()==0);
 
   390 	test(generatedUnicode.Length()==0);
 
   407 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   391 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   408 	TEST(state==CnvUtfConverter::KStateDefault);
 
   392 	test(state==CnvUtfConverter::KStateDefault);
 
   409 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   393 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+AB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   410 	TEST(state==CnvUtfConverter::KStateDefault);
 
   394 	test(state==CnvUtfConverter::KStateDefault);
 
   411 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA"), state)==2);
 
   395 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA"), state)==2);
 
   412 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   396 	test(state!=CnvUtfConverter::KStateDefault);
 
   413 	state=CnvUtfConverter::KStateDefault;
 
   397 	state=CnvUtfConverter::KStateDefault;
 
   414 	TEST(generatedUnicode.Length()==0);
 
   398 	test(generatedUnicode.Length()==0);
 
   415 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   399 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   416 	TEST(state==CnvUtfConverter::KStateDefault);
 
   400 	test(state==CnvUtfConverter::KStateDefault);
 
   417 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   401 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   418 	TEST(state==CnvUtfConverter::KStateDefault);
 
   402 	test(state==CnvUtfConverter::KStateDefault);
 
   419 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB"), state)==2);
 
   403 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB"), state)==2);
 
   420 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   404 	test(state!=CnvUtfConverter::KStateDefault);
 
   421 	state=CnvUtfConverter::KStateDefault;
 
   405 	state=CnvUtfConverter::KStateDefault;
 
   422 	TEST(generatedUnicode.Length()==0);
 
   406 	test(generatedUnicode.Length()==0);
 
   423 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   407 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   424 	TEST(state==CnvUtfConverter::KStateDefault);
 
   408 	test(state==CnvUtfConverter::KStateDefault);
 
   425 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   409 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+BB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   426 	TEST(state==CnvUtfConverter::KStateDefault);
 
   410 	test(state==CnvUtfConverter::KStateDefault);
 
   427 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY"), state)==0);
 
   411 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY"), state)==0);
 
   428 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   412 	test(state!=CnvUtfConverter::KStateDefault);
 
   429 	state=CnvUtfConverter::KStateDefault;
 
   413 	state=CnvUtfConverter::KStateDefault;
 
   430 	TEST(generatedUnicode.Length()==1);
 
   414 	test(generatedUnicode.Length()==1);
 
   431 	TEST(generatedUnicode[0]==0xb676);
 
   415 	test(generatedUnicode[0]==0xb676);
 
   432 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY "), state)==0);
 
   416 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY "), state)==0);
 
   433 	TEST(state==CnvUtfConverter::KStateDefault);
 
   417 	test(state==CnvUtfConverter::KStateDefault);
 
   434 	TEST(generatedUnicode.Length()==2);
 
   418 	test(generatedUnicode.Length()==2);
 
   435 	TEST(generatedUnicode[0]==0xb676);
 
   419 	test(generatedUnicode[0]==0xb676);
 
   436 	TEST(generatedUnicode[1]==0x0020);
 
   420 	test(generatedUnicode[1]==0x0020);
 
   437 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY-"), state)==0);
 
   421 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnY-"), state)==0);
 
   438 	TEST(state==CnvUtfConverter::KStateDefault);
 
   422 	test(state==CnvUtfConverter::KStateDefault);
 
   439 	TEST(generatedUnicode.Length()==1);
 
   423 	test(generatedUnicode.Length()==1);
 
   440 	TEST(generatedUnicode[0]==0xb676);
 
   424 	test(generatedUnicode[0]==0xb676);
 
   441 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ"), state)==3);
 
   425 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ"), state)==3);
 
   442 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   426 	test(state!=CnvUtfConverter::KStateDefault);
 
   443 	state=CnvUtfConverter::KStateDefault;
 
   427 	state=CnvUtfConverter::KStateDefault;
 
   444 	TEST(generatedUnicode.Length()==0);
 
   428 	test(generatedUnicode.Length()==0);
 
   445 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   429 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   446 	TEST(state==CnvUtfConverter::KStateDefault);
 
   430 	test(state==CnvUtfConverter::KStateDefault);
 
   447 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   431 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZ-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   448 	TEST(state==CnvUtfConverter::KStateDefault);
 
   432 	test(state==CnvUtfConverter::KStateDefault);
 
   449 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna"), state)==3);
 
   433 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna"), state)==3);
 
   450 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   434 	test(state!=CnvUtfConverter::KStateDefault);
 
   451 	state=CnvUtfConverter::KStateDefault;
 
   435 	state=CnvUtfConverter::KStateDefault;
 
   452 	TEST(generatedUnicode.Length()==0);
 
   436 	test(generatedUnicode.Length()==0);
 
   453 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   437 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   454 	TEST(state==CnvUtfConverter::KStateDefault);
 
   438 	test(state==CnvUtfConverter::KStateDefault);
 
   455 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   439 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tna-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   456 	TEST(state==CnvUtfConverter::KStateDefault);
 
   440 	test(state==CnvUtfConverter::KStateDefault);
 
   457 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb"), state)==3);
 
   441 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb"), state)==3);
 
   458 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   442 	test(state!=CnvUtfConverter::KStateDefault);
 
   459 	state=CnvUtfConverter::KStateDefault;
 
   443 	state=CnvUtfConverter::KStateDefault;
 
   460 	TEST(generatedUnicode.Length()==0);
 
   444 	test(generatedUnicode.Length()==0);
 
   461 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   445 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   462 	TEST(state==CnvUtfConverter::KStateDefault);
 
   446 	test(state==CnvUtfConverter::KStateDefault);
 
   463 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   447 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnb-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   464 	TEST(state==CnvUtfConverter::KStateDefault);
 
   448 	test(state==CnvUtfConverter::KStateDefault);
 
   465 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA"), state)==0);
 
   449 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA"), state)==0);
 
   466 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   450 	test(state!=CnvUtfConverter::KStateDefault);
 
   467 	state=CnvUtfConverter::KStateDefault;
 
   451 	state=CnvUtfConverter::KStateDefault;
 
   468 	TEST(generatedUnicode.Length()==1);
 
   452 	test(generatedUnicode.Length()==1);
 
   469 	TEST(generatedUnicode[0]==0xb676);
 
   453 	test(generatedUnicode[0]==0xb676);
 
   470 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA "), state)==0);
 
   454 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA "), state)==0);
 
   471 	TEST(state==CnvUtfConverter::KStateDefault);
 
   455 	test(state==CnvUtfConverter::KStateDefault);
 
   472 	TEST(generatedUnicode.Length()==2);
 
   456 	test(generatedUnicode.Length()==2);
 
   473 	TEST(generatedUnicode[0]==0xb676);
 
   457 	test(generatedUnicode[0]==0xb676);
 
   474 	TEST(generatedUnicode[1]==0x0020);
 
   458 	test(generatedUnicode[1]==0x0020);
 
   475 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA-"), state)==0);
 
   459 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYA-"), state)==0);
 
   476 	TEST(state==CnvUtfConverter::KStateDefault);
 
   460 	test(state==CnvUtfConverter::KStateDefault);
 
   477 	TEST(generatedUnicode.Length()==1);
 
   461 	test(generatedUnicode.Length()==1);
 
   478 	TEST(generatedUnicode[0]==0xb676);
 
   462 	test(generatedUnicode[0]==0xb676);
 
   479 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB"), state)==1);
 
   463 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB"), state)==1);
 
   480 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   464 	test(state!=CnvUtfConverter::KStateDefault);
 
   481 	state=CnvUtfConverter::KStateDefault;
 
   465 	state=CnvUtfConverter::KStateDefault;
 
   482 	TEST(generatedUnicode.Length()==1);
 
   466 	test(generatedUnicode.Length()==1);
 
   483 	TEST(generatedUnicode[0]==0xb676);
 
   467 	test(generatedUnicode[0]==0xb676);
 
   484 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   468 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   485 	TEST(state==CnvUtfConverter::KStateDefault);
 
   469 	test(state==CnvUtfConverter::KStateDefault);
 
   486 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   470 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   487 	TEST(state==CnvUtfConverter::KStateDefault);
 
   471 	test(state==CnvUtfConverter::KStateDefault);
 
   488 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA"), state)==1);
 
   472 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA"), state)==1);
 
   489 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   473 	test(state!=CnvUtfConverter::KStateDefault);
 
   490 	state=CnvUtfConverter::KStateDefault;
 
   474 	state=CnvUtfConverter::KStateDefault;
 
   491 	TEST(generatedUnicode.Length()==1);
 
   475 	test(generatedUnicode.Length()==1);
 
   492 	TEST(generatedUnicode[0]==0xb676);
 
   476 	test(generatedUnicode[0]==0xb676);
 
   493 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   477 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   494 	TEST(state==CnvUtfConverter::KStateDefault);
 
   478 	test(state==CnvUtfConverter::KStateDefault);
 
   495 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   479 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   496 	TEST(state==CnvUtfConverter::KStateDefault);
 
   480 	test(state==CnvUtfConverter::KStateDefault);
 
   497 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB"), state)==1);
 
   481 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB"), state)==1);
 
   498 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   482 	test(state!=CnvUtfConverter::KStateDefault);
 
   499 	state=CnvUtfConverter::KStateDefault;
 
   483 	state=CnvUtfConverter::KStateDefault;
 
   500 	TEST(generatedUnicode.Length()==1);
 
   484 	test(generatedUnicode.Length()==1);
 
   501 	TEST(generatedUnicode[0]==0xb676);
 
   485 	test(generatedUnicode[0]==0xb676);
 
   502 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   486 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   503 	TEST(state==CnvUtfConverter::KStateDefault);
 
   487 	test(state==CnvUtfConverter::KStateDefault);
 
   504 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   488 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   505 	TEST(state==CnvUtfConverter::KStateDefault);
 
   489 	test(state==CnvUtfConverter::KStateDefault);
 
   506 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA"), state)==0);
 
   490 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA"), state)==0);
 
   507 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   491 	test(state!=CnvUtfConverter::KStateDefault);
 
   508 	state=CnvUtfConverter::KStateDefault;
 
   492 	state=CnvUtfConverter::KStateDefault;
 
   509 	TEST(generatedUnicode.Length()==1);
 
   493 	test(generatedUnicode.Length()==1);
 
   510 	TEST(generatedUnicode[0]==0xb676);
 
   494 	test(generatedUnicode[0]==0xb676);
 
   511 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA "), state)==0);
 
   495 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA "), state)==0);
 
   512 	TEST(state==CnvUtfConverter::KStateDefault);
 
   496 	test(state==CnvUtfConverter::KStateDefault);
 
   513 	TEST(generatedUnicode.Length()==2);
 
   497 	test(generatedUnicode.Length()==2);
 
   514 	TEST(generatedUnicode[0]==0xb676);
 
   498 	test(generatedUnicode[0]==0xb676);
 
   515 	TEST(generatedUnicode[1]==0x0020);
 
   499 	test(generatedUnicode[1]==0x0020);
 
   516 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA-"), state)==0);
 
   500 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAA-"), state)==0);
 
   517 	TEST(state==CnvUtfConverter::KStateDefault);
 
   501 	test(state==CnvUtfConverter::KStateDefault);
 
   518 	TEST(generatedUnicode.Length()==1);
 
   502 	test(generatedUnicode.Length()==1);
 
   519 	TEST(generatedUnicode[0]==0xb676);
 
   503 	test(generatedUnicode[0]==0xb676);
 
   520 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB"), state)==2);
 
   504 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB"), state)==2);
 
   521 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   505 	test(state!=CnvUtfConverter::KStateDefault);
 
   522 	state=CnvUtfConverter::KStateDefault;
 
   506 	state=CnvUtfConverter::KStateDefault;
 
   523 	TEST(generatedUnicode.Length()==1);
 
   507 	test(generatedUnicode.Length()==1);
 
   524 	TEST(generatedUnicode[0]==0xb676);
 
   508 	test(generatedUnicode[0]==0xb676);
 
   525 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   509 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   526 	TEST(state==CnvUtfConverter::KStateDefault);
 
   510 	test(state==CnvUtfConverter::KStateDefault);
 
   527 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   511 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYAB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   528 	TEST(state==CnvUtfConverter::KStateDefault);
 
   512 	test(state==CnvUtfConverter::KStateDefault);
 
   529 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA"), state)==2);
 
   513 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA"), state)==2);
 
   530 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   514 	test(state!=CnvUtfConverter::KStateDefault);
 
   531 	state=CnvUtfConverter::KStateDefault;
 
   515 	state=CnvUtfConverter::KStateDefault;
 
   532 	TEST(generatedUnicode.Length()==1);
 
   516 	test(generatedUnicode.Length()==1);
 
   533 	TEST(generatedUnicode[0]==0xb676);
 
   517 	test(generatedUnicode[0]==0xb676);
 
   534 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   518 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   535 	TEST(state==CnvUtfConverter::KStateDefault);
 
   519 	test(state==CnvUtfConverter::KStateDefault);
 
   536 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   520 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   537 	TEST(state==CnvUtfConverter::KStateDefault);
 
   521 	test(state==CnvUtfConverter::KStateDefault);
 
   538 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB"), state)==2);
 
   522 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB"), state)==2);
 
   539 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   523 	test(state!=CnvUtfConverter::KStateDefault);
 
   540 	state=CnvUtfConverter::KStateDefault;
 
   524 	state=CnvUtfConverter::KStateDefault;
 
   541 	TEST(generatedUnicode.Length()==1);
 
   525 	test(generatedUnicode.Length()==1);
 
   542 	TEST(generatedUnicode[0]==0xb676);
 
   526 	test(generatedUnicode[0]==0xb676);
 
   543 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   527 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   544 	TEST(state==CnvUtfConverter::KStateDefault);
 
   528 	test(state==CnvUtfConverter::KStateDefault);
 
   545 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   529 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnYBB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   546 	TEST(state==CnvUtfConverter::KStateDefault);
 
   530 	test(state==CnvUtfConverter::KStateDefault);
 
   547 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA"), state)==2);
 
   531 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA"), state)==2);
 
   548 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   532 	test(state!=CnvUtfConverter::KStateDefault);
 
   549 	state=CnvUtfConverter::KStateDefault;
 
   533 	state=CnvUtfConverter::KStateDefault;
 
   550 	TEST(generatedUnicode.Length()==1);
 
   534 	test(generatedUnicode.Length()==1);
 
   551 	TEST(generatedUnicode[0]==0xb676);
 
   535 	test(generatedUnicode[0]==0xb676);
 
   552 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   536 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   553 	TEST(state==CnvUtfConverter::KStateDefault);
 
   537 	test(state==CnvUtfConverter::KStateDefault);
 
   554 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   538 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   555 	TEST(state==CnvUtfConverter::KStateDefault);
 
   539 	test(state==CnvUtfConverter::KStateDefault);
 
   556 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB"), state)==2);
 
   540 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB"), state)==2);
 
   557 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   541 	test(state!=CnvUtfConverter::KStateDefault);
 
   558 	state=CnvUtfConverter::KStateDefault;
 
   542 	state=CnvUtfConverter::KStateDefault;
 
   559 	TEST(generatedUnicode.Length()==1);
 
   543 	test(generatedUnicode.Length()==1);
 
   560 	TEST(generatedUnicode[0]==0xb676);
 
   544 	test(generatedUnicode[0]==0xb676);
 
   561 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   545 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   562 	TEST(state==CnvUtfConverter::KStateDefault);
 
   546 	test(state==CnvUtfConverter::KStateDefault);
 
   563 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   547 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZAB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   564 	TEST(state==CnvUtfConverter::KStateDefault);
 
   548 	test(state==CnvUtfConverter::KStateDefault);
 
   565 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA"), state)==2);
 
   549 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA"), state)==2);
 
   566 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   550 	test(state!=CnvUtfConverter::KStateDefault);
 
   567 	state=CnvUtfConverter::KStateDefault;
 
   551 	state=CnvUtfConverter::KStateDefault;
 
   568 	TEST(generatedUnicode.Length()==1);
 
   552 	test(generatedUnicode.Length()==1);
 
   569 	TEST(generatedUnicode[0]==0xb676);
 
   553 	test(generatedUnicode[0]==0xb676);
 
   570 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   554 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   571 	TEST(state==CnvUtfConverter::KStateDefault);
 
   555 	test(state==CnvUtfConverter::KStateDefault);
 
   572 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   556 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBA-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   573 	TEST(state==CnvUtfConverter::KStateDefault);
 
   557 	test(state==CnvUtfConverter::KStateDefault);
 
   574 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB"), state)==2);
 
   558 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB"), state)==2);
 
   575 	TEST(state!=CnvUtfConverter::KStateDefault);
 
   559 	test(state!=CnvUtfConverter::KStateDefault);
 
   576 	state=CnvUtfConverter::KStateDefault;
 
   560 	state=CnvUtfConverter::KStateDefault;
 
   577 	TEST(generatedUnicode.Length()==1);
 
   561 	test(generatedUnicode.Length()==1);
 
   578 	TEST(generatedUnicode[0]==0xb676);
 
   562 	test(generatedUnicode[0]==0xb676);
 
   579 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   563 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB "), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   580 	TEST(state==CnvUtfConverter::KStateDefault);
 
   564 	test(state==CnvUtfConverter::KStateDefault);
 
   581 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   565 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+tnZBB-"), state)==CnvUtfConverter::EErrorIllFormedInput);
 
   582 	TEST(state==CnvUtfConverter::KStateDefault);
 
   566 	test(state==CnvUtfConverter::KStateDefault);
 
   583 	}
 
   567 	}
 
   584 	{
 
   568 	{
 
   585 	TheTest.Next(_L("Testing converting bad UTF-8 to Unicode"));
 
   569 	INFO_PRINTF1(_L("Testing converting bad UTF-8 to Unicode"));
 
   586 	utf8.Format(percentC_8, 0x80);
 
   570 	utf8.Format(percentC_8, 0x80);
 
   587 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   571 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   588 	utf8.Format(percentC_8, 0xbf);
 
   572 	utf8.Format(percentC_8, 0xbf);
 
   589 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   573 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   590 	utf8.Format(percentC_8, 0xa1);
 
   574 	utf8.Format(percentC_8, 0xa1);
 
   591 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   575 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   592 	utf8.Format(percentC_8, 0xc0);
 
   576 	utf8.Format(percentC_8, 0xc0);
 
   593 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   577 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   594 	utf8.Format(percentCPercentC_8, '=', 0xc0);
 
   578 	utf8.Format(percentCPercentC_8, '=', 0xc0);
 
   595 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   579 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   596 	TEST(generatedUnicode.Length()==2);
 
   580 	test(generatedUnicode.Length()==2);
 
   597 	TEST(generatedUnicode[0]=='=');
 
   581 	test(generatedUnicode[0]=='=');
 
   598 	TEST(generatedUnicode[1]==0xFFFD);
 
   582 	test(generatedUnicode[1]==0xFFFD);
 
   599 	utf8.Format(percentCPercentC_8, 0xc0, 0x00);
 
   583 	utf8.Format(percentCPercentC_8, 0xc0, 0x00);
 
   600 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   584 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   601 	utf8.Format(percentCPercentC_8, 0xc0, 0x80);
 
   585 	utf8.Format(percentCPercentC_8, 0xc0, 0x80);
 
   602 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   586 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   603 	TEST(generatedUnicode.Length()==2);
 
   587 	test(generatedUnicode.Length()==2);
 
   604 	TEST(generatedUnicode[0]==0xFFFD);
 
   588 	test(generatedUnicode[0]==0xFFFD);
 
   605 	TEST(generatedUnicode[1]==0xFFFD);
 
   589 	test(generatedUnicode[1]==0xFFFD);
 
   606 	utf8.Format(percentC_8, 0xdf);
 
   590 	utf8.Format(percentC_8, 0xdf);
 
   607 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   591 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   608 	utf8.Format(percentCPercentC_8, '*', 0xdf);
 
   592 	utf8.Format(percentCPercentC_8, '*', 0xdf);
 
   609 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   593 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   610 	TEST(generatedUnicode.Length()==1);
 
   594 	test(generatedUnicode.Length()==1);
 
   611 	TEST(generatedUnicode[0]=='*');
 
   595 	test(generatedUnicode[0]=='*');
 
   612 	utf8.Format(percentCPercentC_8, 0xdf, 0x7f);
 
   596 	utf8.Format(percentCPercentC_8, 0xdf, 0x7f);
 
   613 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   597 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   614 	utf8.Format(percentCPercentC_8, 0xdf, 0xbf);
 
   598 	utf8.Format(percentCPercentC_8, 0xdf, 0xbf);
 
   615 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   599 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   616 	TEST(generatedUnicode.Length()==1);
 
   600 	test(generatedUnicode.Length()==1);
 
   617 	TEST(generatedUnicode[0]==0x07ff);
 
   601 	test(generatedUnicode[0]==0x07ff);
 
   618 	utf8.Format(percentC_8, 0xd7);
 
   602 	utf8.Format(percentC_8, 0xd7);
 
   619 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   603 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   620 	utf8.Format(percentCPercentC_8, '\'', 0xd7);
 
   604 	utf8.Format(percentCPercentC_8, '\'', 0xd7);
 
   621 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   605 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   622 	TEST(generatedUnicode.Length()==1);
 
   606 	test(generatedUnicode.Length()==1);
 
   623 	TEST(generatedUnicode[0]=='\'');
 
   607 	test(generatedUnicode[0]=='\'');
 
   624 	utf8.Format(percentCPercentC_8, 0xd7, 0xd9);
 
   608 	utf8.Format(percentCPercentC_8, 0xd7, 0xd9);
 
   625 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   609 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   626 	utf8.Format(percentCPercentC_8, 0xd7, 0x99);
 
   610 	utf8.Format(percentCPercentC_8, 0xd7, 0x99);
 
   627 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   611 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   628 	TEST(generatedUnicode.Length()==1);
 
   612 	test(generatedUnicode.Length()==1);
 
   629 	TEST(generatedUnicode[0]==0x05d9);
 
   613 	test(generatedUnicode[0]==0x05d9);
 
   630 	utf8.Format(percentC_8, 0xe0);
 
   614 	utf8.Format(percentC_8, 0xe0);
 
   631 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   615 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   632 	utf8.Format(percentCPercentC_8, '@', 0xe0);
 
   616 	utf8.Format(percentCPercentC_8, '@', 0xe0);
 
   633 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   617 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   634 	TEST(generatedUnicode.Length()==1);
 
   618 	test(generatedUnicode.Length()==1);
 
   635 	TEST(generatedUnicode[0]=='@');
 
   619 	test(generatedUnicode[0]=='@');
 
   636 	utf8.Format(percentCPercentC_8, 0xe0, 0x80);
 
   620 	utf8.Format(percentCPercentC_8, 0xe0, 0x80);
 
   637 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   621 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   638 	utf8.Format(percentCPercentCPercentC_8, ':', 0xe0, 0x80);
 
   622 	utf8.Format(percentCPercentCPercentC_8, ':', 0xe0, 0x80);
 
   639 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   623 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   640 	TEST(generatedUnicode.Length()==1);
 
   624 	test(generatedUnicode.Length()==1);
 
   641 	TEST(generatedUnicode[0]==':');
 
   625 	test(generatedUnicode[0]==':');
 
   642 	utf8.Format(percentCPercentCPercentC_8, 0xe0, 0x80, 0x80);
 
   626 	utf8.Format(percentCPercentCPercentC_8, 0xe0, 0x80, 0x80);
 
   643 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   627 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   644 	TEST(generatedUnicode.Length()==3);
 
   628 	test(generatedUnicode.Length()==3);
 
   645 	TEST(generatedUnicode[0]==0xfffd);
 
   629 	test(generatedUnicode[0]==0xfffd);
 
   646 	TEST(generatedUnicode[1]==0xfffd);
 
   630 	test(generatedUnicode[1]==0xfffd);
 
   647 	TEST(generatedUnicode[2]==0xfffd);
 
   631 	test(generatedUnicode[2]==0xfffd);
 
   648 	utf8.Format(percentCPercentC_8, 0xef, 0x3f);
 
   632 	utf8.Format(percentCPercentC_8, 0xef, 0x3f);
 
   649 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   633 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   650 	utf8.Format(percentCPercentCPercentC_8, '~', 0xef, 0x3f);
 
   634 	utf8.Format(percentCPercentCPercentC_8, '~', 0xef, 0x3f);
 
   651 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   635 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   652 	TEST(generatedUnicode.Length()==1);
 
   636 	test(generatedUnicode.Length()==1);
 
   653 	TEST(generatedUnicode[0]=='~');
 
   637 	test(generatedUnicode[0]=='~');
 
   654 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0x3f, 0xbf);
 
   638 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0x3f, 0xbf);
 
   655 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   639 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   656 	utf8.Format(percentCPercentC_8, 0xef, 0x7f);
 
   640 	utf8.Format(percentCPercentC_8, 0xef, 0x7f);
 
   657 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   641 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   658 	utf8.Format(percentCPercentCPercentC_8, 'L', 0xef, 0x7f);
 
   642 	utf8.Format(percentCPercentCPercentC_8, 'L', 0xef, 0x7f);
 
   659 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   643 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   660 	TEST(generatedUnicode.Length()==1);
 
   644 	test(generatedUnicode.Length()==1);
 
   661 	TEST(generatedUnicode[0]=='L');
 
   645 	test(generatedUnicode[0]=='L');
 
   662 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0x7f, 0xbf);
 
   646 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0x7f, 0xbf);
 
   663 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   647 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   664 	utf8.Format(percentCPercentC_8, 0xef, 0xff);
 
   648 	utf8.Format(percentCPercentC_8, 0xef, 0xff);
 
   665 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   649 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   666 	utf8.Format(percentCPercentCPercentC_8, '^', 0xef, 0xff);
 
   650 	utf8.Format(percentCPercentCPercentC_8, '^', 0xef, 0xff);
 
   667 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   651 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   668 	TEST(generatedUnicode.Length()==1);
 
   652 	test(generatedUnicode.Length()==1);
 
   669 	TEST(generatedUnicode[0]=='^');
 
   653 	test(generatedUnicode[0]=='^');
 
   670 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xff, 0xbf);
 
   654 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xff, 0xbf);
 
   671 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   655 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   672 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0x3f);
 
   656 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0x3f);
 
   673 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   657 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   674 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0x7f);
 
   658 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0x7f);
 
   675 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   659 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   676 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0xff);
 
   660 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0xff);
 
   677 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   661 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   678 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0xbf);
 
   662 	utf8.Format(percentCPercentCPercentC_8, 0xef, 0xbf, 0xbf);
 
   679 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   663 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   680 	TEST(generatedUnicode.Length()==1);
 
   664 	test(generatedUnicode.Length()==1);
 
   681 	TEST(generatedUnicode[0]==0xffff);
 
   665 	test(generatedUnicode[0]==0xffff);
 
   682 	utf8.Format(percentC_8, 0xf4);
 
   666 	utf8.Format(percentC_8, 0xf4);
 
   683 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   667 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   684 	utf8.Format(percentCPercentC_8, ',', 0xf4);
 
   668 	utf8.Format(percentCPercentC_8, ',', 0xf4);
 
   685 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   669 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   686 	TEST(generatedUnicode.Length()==1);
 
   670 	test(generatedUnicode.Length()==1);
 
   687 	TEST(generatedUnicode[0]==',');
 
   671 	test(generatedUnicode[0]==',');
 
   688 	utf8.Format(percentCPercentC_8, 0xf4, 0x06);
 
   672 	utf8.Format(percentCPercentC_8, 0xf4, 0x06);
 
   689 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   673 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   690 	utf8.Format(percentCPercentCPercentC_8, 'J', 0xf4, 0x06);
 
   674 	utf8.Format(percentCPercentCPercentC_8, 'J', 0xf4, 0x06);
 
   691 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   675 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   692 	TEST(generatedUnicode.Length()==1);
 
   676 	test(generatedUnicode.Length()==1);
 
   693 	TEST(generatedUnicode[0]=='J');
 
   677 	test(generatedUnicode[0]=='J');
 
   694 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x06, 0xab);
 
   678 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x06, 0xab);
 
   695 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   679 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   696 	utf8.Format(percentCPercentCPercentCPercentC_8, ']', 0xf4, 0x06, 0xab);
 
   680 	utf8.Format(percentCPercentCPercentCPercentC_8, ']', 0xf4, 0x06, 0xab);
 
   697 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   681 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   698 	TEST(generatedUnicode.Length()==1);
 
   682 	test(generatedUnicode.Length()==1);
 
   699 	TEST(generatedUnicode[0]==']');
 
   683 	test(generatedUnicode[0]==']');
 
   700 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x06, 0xab, 0x9c);
 
   684 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x06, 0xab, 0x9c);
 
   701 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   685 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   702 	utf8.Format(percentCPercentC_8, 0xf4, 0x46);
 
   686 	utf8.Format(percentCPercentC_8, 0xf4, 0x46);
 
   703 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   687 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   704 	utf8.Format(percentCPercentCPercentC_8, 'o', 0xf4, 0x46);
 
   688 	utf8.Format(percentCPercentCPercentC_8, 'o', 0xf4, 0x46);
 
   705 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   689 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   706 	TEST(generatedUnicode.Length()==1);
 
   690 	test(generatedUnicode.Length()==1);
 
   707 	TEST(generatedUnicode[0]=='o');
 
   691 	test(generatedUnicode[0]=='o');
 
   708 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x46, 0xab);
 
   692 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x46, 0xab);
 
   709 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   693 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   710 	utf8.Format(percentCPercentCPercentCPercentC_8, '!', 0xf4, 0x46, 0xab);
 
   694 	utf8.Format(percentCPercentCPercentCPercentC_8, '!', 0xf4, 0x46, 0xab);
 
   711 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   695 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   712 	TEST(generatedUnicode.Length()==1);
 
   696 	test(generatedUnicode.Length()==1);
 
   713 	TEST(generatedUnicode[0]=='!');
 
   697 	test(generatedUnicode[0]=='!');
 
   714 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x46, 0xab, 0x9c);
 
   698 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x46, 0xab, 0x9c);
 
   715 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   699 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   716 	utf8.Format(percentCPercentC_8, 0xf4, 0xc6);
 
   700 	utf8.Format(percentCPercentC_8, 0xf4, 0xc6);
 
   717 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   701 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   718 	utf8.Format(percentCPercentCPercentC_8, 'm', 0xf4, 0xc6);
 
   702 	utf8.Format(percentCPercentCPercentC_8, 'm', 0xf4, 0xc6);
 
   719 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   703 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   720 	TEST(generatedUnicode.Length()==1);
 
   704 	test(generatedUnicode.Length()==1);
 
   721 	TEST(generatedUnicode[0]=='m');
 
   705 	test(generatedUnicode[0]=='m');
 
   722 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0xc6, 0xab);
 
   706 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0xc6, 0xab);
 
   723 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   707 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   724 	utf8.Format(percentCPercentCPercentCPercentC_8, '&', 0xf4, 0xc6, 0xab);
 
   708 	utf8.Format(percentCPercentCPercentCPercentC_8, '&', 0xf4, 0xc6, 0xab);
 
   725 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   709 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   726 	TEST(generatedUnicode.Length()==1);
 
   710 	test(generatedUnicode.Length()==1);
 
   727 	TEST(generatedUnicode[0]=='&');
 
   711 	test(generatedUnicode[0]=='&');
 
   728 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0xc6, 0xab, 0x9c);
 
   712 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0xc6, 0xab, 0x9c);
 
   729 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   713 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   730 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0x2b);
 
   714 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0x2b);
 
   731 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   715 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   732 	utf8.Format(percentCPercentCPercentCPercentC_8, 'v', 0xf4, 0x86, 0x2b);
 
   716 	utf8.Format(percentCPercentCPercentCPercentC_8, 'v', 0xf4, 0x86, 0x2b);
 
   733 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   717 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   734 	TEST(generatedUnicode.Length()==1);
 
   718 	test(generatedUnicode.Length()==1);
 
   735 	TEST(generatedUnicode[0]=='v');
 
   719 	test(generatedUnicode[0]=='v');
 
   736 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0x2b, 0x9c);
 
   720 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0x2b, 0x9c);
 
   737 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   721 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   738 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0x6b);
 
   722 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0x6b);
 
   739 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   723 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   740 	utf8.Format(percentCPercentCPercentCPercentC_8, 'Q', 0xf4, 0x86, 0x6b);
 
   724 	utf8.Format(percentCPercentCPercentCPercentC_8, 'Q', 0xf4, 0x86, 0x6b);
 
   741 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   725 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   742 	TEST(generatedUnicode.Length()==1);
 
   726 	test(generatedUnicode.Length()==1);
 
   743 	TEST(generatedUnicode[0]=='Q');
 
   727 	test(generatedUnicode[0]=='Q');
 
   744 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0x6b, 0x9c);
 
   728 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0x6b, 0x9c);
 
   745 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   729 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   746 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0xeb);
 
   730 	utf8.Format(percentCPercentCPercentC_8, 0xf4, 0x86, 0xeb);
 
   747 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   731 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==CnvUtfConverter::EErrorIllFormedInput);
 
   748 	utf8.Format(percentCPercentCPercentCPercentC_8, '?', 0xf4, 0x86, 0xeb);
 
   732 	utf8.Format(percentCPercentCPercentCPercentC_8, '?', 0xf4, 0x86, 0xeb);
 
   749 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   733 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==3);
 
   750 	TEST(generatedUnicode.Length()==1);
 
   734 	test(generatedUnicode.Length()==1);
 
   751 	TEST(generatedUnicode[0]=='?');
 
   735 	test(generatedUnicode[0]=='?');
 
   752 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xeb, 0x9c);
 
   736 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xeb, 0x9c);
 
   753 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   737 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==2);
 
   754 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x1c);
 
   738 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x1c);
 
   755 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   739 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   756 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x5c);
 
   740 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x5c);
 
   757 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   741 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   758 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0xdc);
 
   742 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0xdc);
 
   759 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   743 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==1);
 
   760 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x9c);
 
   744 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x86, 0xab, 0x9c);
 
   761 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   745 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   762 	TEST(generatedUnicode.Length()==2);
 
   746 	test(generatedUnicode.Length()==2);
 
   763 	TEST(generatedUnicode[0]==0xdbda);
 
   747 	test(generatedUnicode[0]==0xdbda);
 
   764 	TEST(generatedUnicode[1]==0xdedc);
 
   748 	test(generatedUnicode[1]==0xdedc);
 
   765 
   749 
   766 	// Additional tests added for INC117111...
 
   750 	// Additional tests added for INC117111...
 
   767 
   751 
   768 	utf8.Format(_L8("%c%c%c%c"), 0xf4, 0xc6, 0xab, 0x9c);     // Invalid 4 bit
 
   752 	utf8.Format(_L8("%c%c%c%c"), 0xf4, 0xc6, 0xab, 0x9c);     // Invalid 4 bit
 
   769 	TInt returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   753 	TInt returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   770 	TEST(generatedUnicode.Length()==3);
 
   754 	test(generatedUnicode.Length()==3);
 
   771 	TEST(generatedUnicode[0]==0xFFFD);
 
   755 	test(generatedUnicode[0]==0xFFFD);
 
   772 	TEST(generatedUnicode[1]==0x01AB);
 
   756 	test(generatedUnicode[1]==0x01AB);
 
   773 	TEST(generatedUnicode[2]==0xFFFD);
 
   757 	test(generatedUnicode[2]==0xFFFD);
 
   774 
   758 
   775 	unicode.Format(percentCPercentC_16, 0xd800, 0xdc00); // a surrogate pair
 
   759 	unicode.Format(percentCPercentC_16, 0xd800, 0xdc00); // a surrogate pair
 
   776 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   760 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   777 
   761 
   778 	TEST(generatedUtf8==_L8("\xf0\x90\x80\x80")); // round trip test
 
   762 	test(generatedUtf8==_L8("\xf0\x90\x80\x80")); // round trip test
 
   779 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, generatedUtf8);
 
   763 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, generatedUtf8);
 
   780 	TEST(generatedUnicode.Length()==2);
 
   764 	test(generatedUnicode.Length()==2);
 
   781 	TEST(generatedUnicode[0]==0xd800);
 
   765 	test(generatedUnicode[0]==0xd800);
 
   782 	TEST(generatedUnicode[1]==0xdc00);
 
   766 	test(generatedUnicode[1]==0xdc00);
 
   783 
   767 
   784 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdfff);
 
   768 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdfff);
 
   785 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   769 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   786 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xed\xbf\xbf"));
 
   770 	test(generatedUtf8==_L8("\xed\x9f\xbf\xed\xbf\xbf"));
 
   787 
   771 
   788 	utf8.Format(_L8("%c"), 0xc0); // An invalid char.
 
   772 	utf8.Format(_L8("%c"), 0xc0); // An invalid char.
 
   789 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   773 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   790 	TEST(generatedUnicode.Length()==1);
 
   774 	test(generatedUnicode.Length()==1);
 
   791 	TEST(generatedUnicode[0]==0xFFFD);
 
   775 	test(generatedUnicode[0]==0xFFFD);
 
   792 
   776 
   793 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x20, 0x01, 0x02, 0x10); // Invalid 4 bit and a ASCI
 
   777 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x20, 0x01, 0x02, 0x10); // Invalid 4 bit and a ASCI
 
   794 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   778 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   795 	TEST(generatedUnicode.Length()==5);
 
   779 	test(generatedUnicode.Length()==5);
 
   796 	TEST(generatedUnicode[0]==0xFFFD);
 
   780 	test(generatedUnicode[0]==0xFFFD);
 
   797 	TEST(generatedUnicode[1]==0x0020);
 
   781 	test(generatedUnicode[1]==0x0020);
 
   798 	TEST(generatedUnicode[2]==0x0001);
 
   782 	test(generatedUnicode[2]==0x0001);
 
   799 	TEST(generatedUnicode[3]==0x0002);
 
   783 	test(generatedUnicode[3]==0x0002);
 
   800 	TEST(generatedUnicode[4]==0x0010);
 
   784 	test(generatedUnicode[4]==0x0010);
 
   801 
   785 
   802 	utf8.Format(_L8("%c%c%c%c"), 0xed, 0xa0, 0x80, 0x10);		// Invalid 3 bit and a ASCI
 
   786 	utf8.Format(_L8("%c%c%c%c"), 0xed, 0xa0, 0x80, 0x10);		// Invalid 3 bit and a ASCI
 
   803 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   787 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   804 	TEST(generatedUnicode.Length()==4);
 
   788 	test(generatedUnicode.Length()==4);
 
   805 	TEST(generatedUnicode[0]==0xFFFD);
 
   789 	test(generatedUnicode[0]==0xFFFD);
 
   806 	TEST(generatedUnicode[1]==0xFFFD);
 
   790 	test(generatedUnicode[1]==0xFFFD);
 
   807 	TEST(generatedUnicode[2]==0xFFFD);
 
   791 	test(generatedUnicode[2]==0xFFFD);
 
   808 	TEST(generatedUnicode[3]==0x0010);
 
   792 	test(generatedUnicode[3]==0x0010);
 
   809 
   793 
   810 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x81, 0x81, 0x81, 0x10);     // Valid 4 bit and a ASCI
 
   794 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x81, 0x81, 0x81, 0x10);     // Valid 4 bit and a ASCI
 
   811 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   795 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   812 	TEST(generatedUnicode.Length()==3);
 
   796 	test(generatedUnicode.Length()==3);
 
   813 	TEST(generatedUnicode[0]==0xdbc4);
 
   797 	test(generatedUnicode[0]==0xdbc4);
 
   814 	TEST(generatedUnicode[1]==0xdc41);
 
   798 	test(generatedUnicode[1]==0xdc41);
 
   815 	TEST(generatedUnicode[2]==0x0010);
 
   799 	test(generatedUnicode[2]==0x0010);
 
   816 
   800 
   817 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0xc6, 0xab, 0x9c, 0x10);     // Invalid 4 bit and a ASCI
 
   801 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0xc6, 0xab, 0x9c, 0x10);     // Invalid 4 bit and a ASCI
 
   818 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   802 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   819 	TEST(generatedUnicode.Length()==4);
 
   803 	test(generatedUnicode.Length()==4);
 
   820 	TEST(generatedUnicode[0]==0xFFFD);
 
   804 	test(generatedUnicode[0]==0xFFFD);
 
   821 	TEST(generatedUnicode[1]==0x01AB);
 
   805 	test(generatedUnicode[1]==0x01AB);
 
   822 	TEST(generatedUnicode[2]==0xFFFD);
 
   806 	test(generatedUnicode[2]==0xFFFD);
 
   823 	TEST(generatedUnicode[3]==0x0010);
 
   807 	test(generatedUnicode[3]==0x0010);
 
   824 
   808 
   825 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x8c, 0x81, 0x81, 0x10);     // Valid 4 bit and a ASCI
 
   809 	utf8.Format(_L8("%c%c%c%c%c"), 0xf4, 0x8c, 0x81, 0x81, 0x10);     // Valid 4 bit and a ASCI
 
   826 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   810 	returnval = CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   827 
   811 
   828 	//INC044750
 
   812 	//INC044750
 
   829 	utf8.Format(_L8("%c%c%c%c%c"),0x3C, 0xFC, 0xDC, 0x3C,0x3C);
 
   813 	utf8.Format(_L8("%c%c%c%c%c"),0x3C, 0xFC, 0xDC, 0x3C,0x3C);
 
   830 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   814 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   831 	TEST(generatedUnicode==_L("<\xFFFD\xFFFD<<"));
 
   815 	test(generatedUnicode==_L("<\xFFFD\xFFFD<<"));
 
   832 	}
 
   816 	}
 
   833 	TheTest.Next(_L("Testing bad uuuuu (wwww+1) bits in 4-byte UTF-8"));
 
   817 	INFO_PRINTF1(_L("Testing bad uuuuu (wwww+1) bits in 4-byte UTF-8"));
 
   834 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x96, 0xab, 0x9c);
 
   818 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf4, 0x96, 0xab, 0x9c);
 
   835 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   819 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   836 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf0, 0x86, 0xab, 0x9c);
 
   820 	utf8.Format(percentCPercentCPercentCPercentC_8, 0xf0, 0x86, 0xab, 0x9c);
 
   837 	TEST(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   821 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8)==0);
 
   838 	{
 
   822 	{
 
   839 	TheTest.Next(_L("Testing converting bad Unicode surrogate-pairs to UTF-8"));
 
   823 	INFO_PRINTF1(_L("Testing converting bad Unicode surrogate-pairs to UTF-8"));
 
   840 	unicode.Format(percentC_16, 0xd800);
 
   824 	unicode.Format(percentC_16, 0xd800);
 
   841 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   825 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   842 	unicode.Format(percentCPercentC_16, '>', 0xd800);
 
   826 	unicode.Format(percentCPercentC_16, '>', 0xd800);
 
   843 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   827 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   844 	TEST(generatedUtf8.Length()==1);
 
   828 	test(generatedUtf8.Length()==1);
 
   845 	TEST(generatedUtf8[0]=='>');
 
   829 	test(generatedUtf8[0]=='>');
 
   846 	unicode.Format(percentC_16, 0xdbff);
 
   830 	unicode.Format(percentC_16, 0xdbff);
 
   847 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   831 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   848 	unicode.Format(percentCPercentC_16, 'Z', 0xdbff);
 
   832 	unicode.Format(percentCPercentC_16, 'Z', 0xdbff);
 
   849 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   833 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   850 	TEST(generatedUtf8.Length()==1);
 
   834 	test(generatedUtf8.Length()==1);
 
   851 	TEST(generatedUtf8[0]=='Z');
 
   835 	test(generatedUtf8[0]=='Z');
 
   852 	unicode.Format(percentC_16, 0xdaaa);
 
   836 	unicode.Format(percentC_16, 0xdaaa);
 
   853 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   837 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   854 	unicode.Format(percentCPercentC_16, '|', 0xdaaa);
 
   838 	unicode.Format(percentCPercentC_16, '|', 0xdaaa);
 
   855 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   839 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   856 	TEST(generatedUtf8.Length()==1);
 
   840 	test(generatedUtf8.Length()==1);
 
   857 	TEST(generatedUtf8[0]=='|');
 
   841 	test(generatedUtf8[0]=='|');
 
   858 	unicode.Format(percentC_16, 0xd7ff);
 
   842 	unicode.Format(percentC_16, 0xd7ff);
 
   859 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   843 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   860 	TEST(generatedUtf8==_L8("\xed\x9f\xbf"));
 
   844 	test(generatedUtf8==_L8("\xed\x9f\xbf"));
 
   861 	unicode.Format(percentC_16, 0xdc00);
 
   845 	unicode.Format(percentC_16, 0xdc00);
 
   862 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   846 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   863 	TEST(generatedUtf8==_L8("\xed\xb0\x80"));
 
   847 	test(generatedUtf8==_L8("\xed\xb0\x80"));
 
   864 	unicode.Format(percentCPercentC_16, 0xd800, 0xe000);
 
   848 	unicode.Format(percentCPercentC_16, 0xd800, 0xe000);
 
   865 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   849 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   866 	unicode.Format(percentCPercentC_16, 0xdbff, 0xe000);
 
   850 	unicode.Format(percentCPercentC_16, 0xdbff, 0xe000);
 
   867 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   851 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   868 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xe000);
 
   852 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xe000);
 
   869 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   853 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   870 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xe000);
 
   854 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xe000);
 
   871 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   855 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   872 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xee\x80\x80"));
 
   856 	test(generatedUtf8==_L8("\xed\x9f\xbf\xee\x80\x80"));
 
   873 	unicode.Format(percentCPercentC_16, 0xdc00, 0xe000);
 
   857 	unicode.Format(percentCPercentC_16, 0xdc00, 0xe000);
 
   874 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   858 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   875 	TEST(generatedUtf8==_L8("\xed\xb0\x80\xee\x80\x80"));
 
   859 	test(generatedUtf8==_L8("\xed\xb0\x80\xee\x80\x80"));
 
   876 	unicode.Format(percentCPercentC_16, 0xd800, 0xdbff);
 
   860 	unicode.Format(percentCPercentC_16, 0xd800, 0xdbff);
 
   877 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   861 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   878 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdbff);
 
   862 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdbff);
 
   879 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   863 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   880 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdbff);
 
   864 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdbff);
 
   881 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   865 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   882 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdbff);
 
   866 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdbff);
 
   883 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   867 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   884 	TEST(generatedUtf8==_L8("\xed\x9f\xbf"));
 
   868 	test(generatedUtf8==_L8("\xed\x9f\xbf"));
 
   885 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdbff);
 
   869 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdbff);
 
   886 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   870 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==1);
 
   887 	TEST(generatedUtf8==_L8("\xed\xb0\x80"));
 
   871 	test(generatedUtf8==_L8("\xed\xb0\x80"));
 
   888 	unicode.Format(percentCPercentC_16, 0xd800, 0xd7ff);
 
   872 	unicode.Format(percentCPercentC_16, 0xd800, 0xd7ff);
 
   889 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   873 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   890 	unicode.Format(percentCPercentC_16, 0xdbff, 0xd7ff);
 
   874 	unicode.Format(percentCPercentC_16, 0xdbff, 0xd7ff);
 
   891 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   875 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   892 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xd7ff);
 
   876 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xd7ff);
 
   893 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   877 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==CnvUtfConverter::EErrorIllFormedInput);
 
   894 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xd7ff);
 
   878 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xd7ff);
 
   895 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   879 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   896 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xed\x9f\xbf"));
 
   880 	test(generatedUtf8==_L8("\xed\x9f\xbf\xed\x9f\xbf"));
 
   897 	unicode.Format(percentCPercentC_16, 0xdc00, 0xd7ff);
 
   881 	unicode.Format(percentCPercentC_16, 0xdc00, 0xd7ff);
 
   898 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   882 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   899 	TEST(generatedUtf8==_L8("\xed\xb0\x80\xed\x9f\xbf"));
 
   883 	test(generatedUtf8==_L8("\xed\xb0\x80\xed\x9f\xbf"));
 
   900 	unicode.Format(percentCPercentC_16, 0xd800, 0xdfff);
 
   884 	unicode.Format(percentCPercentC_16, 0xd800, 0xdfff);
 
   901 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   885 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   902 	TEST(generatedUtf8==_L8("\xf0\x90\x8f\xbf"));
 
   886 	test(generatedUtf8==_L8("\xf0\x90\x8f\xbf"));
 
   903 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdfff);
 
   887 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdfff);
 
   904 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   888 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   905 	TEST(generatedUtf8==_L8("\xf4\x8f\xbf\xbf"));
 
   889 	test(generatedUtf8==_L8("\xf4\x8f\xbf\xbf"));
 
   906 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdfff);
 
   890 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdfff);
 
   907 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   891 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   908 	TEST(generatedUtf8==_L8("\xf2\xba\xaf\xbf"));
 
   892 	test(generatedUtf8==_L8("\xf2\xba\xaf\xbf"));
 
   909 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdfff);
 
   893 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdfff);
 
   910 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   894 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   911 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xed\xbf\xbf"));
 
   895 	test(generatedUtf8==_L8("\xed\x9f\xbf\xed\xbf\xbf"));
 
   912 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdfff);
 
   896 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdfff);
 
   913 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   897 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   914 	TEST(generatedUtf8==_L8("\xed\xb0\x80\xed\xbf\xbf"));
 
   898 	test(generatedUtf8==_L8("\xed\xb0\x80\xed\xbf\xbf"));
 
   915 	unicode.Format(percentCPercentC_16, 0xd800, 0xdc00);
 
   899 	unicode.Format(percentCPercentC_16, 0xd800, 0xdc00);
 
   916 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   900 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   917 	TEST(generatedUtf8==_L8("\xf0\x90\x80\x80"));
 
   901 	test(generatedUtf8==_L8("\xf0\x90\x80\x80"));
 
   918 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdc00);
 
   902 	unicode.Format(percentCPercentC_16, 0xdbff, 0xdc00);
 
   919 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   903 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   920 	TEST(generatedUtf8==_L8("\xf4\x8f\xb0\x80"));
 
   904 	test(generatedUtf8==_L8("\xf4\x8f\xb0\x80"));
 
   921 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdc00);
 
   905 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xdc00);
 
   922 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   906 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   923 	TEST(generatedUtf8==_L8("\xf2\xba\xa0\x80"));
 
   907 	test(generatedUtf8==_L8("\xf2\xba\xa0\x80"));
 
   924 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdc00);
 
   908 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xdc00);
 
   925 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   909 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   926 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xed\xb0\x80"));
 
   910 	test(generatedUtf8==_L8("\xed\x9f\xbf\xed\xb0\x80"));
 
   927 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdc00);
 
   911 	unicode.Format(percentCPercentC_16, 0xdc00, 0xdc00);
 
   928 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   912 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   929 	TEST(generatedUtf8==_L8("\xed\xb0\x80\xed\xb0\x80"));
 
   913 	test(generatedUtf8==_L8("\xed\xb0\x80\xed\xb0\x80"));
 
   930 	unicode.Format(percentCPercentC_16, 0xd800, 0xde37);
 
   914 	unicode.Format(percentCPercentC_16, 0xd800, 0xde37);
 
   931 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   915 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   932 	TEST(generatedUtf8==_L8("\xf0\x90\x88\xb7"));
 
   916 	test(generatedUtf8==_L8("\xf0\x90\x88\xb7"));
 
   933 	unicode.Format(percentCPercentC_16, 0xdbff, 0xde37);
 
   917 	unicode.Format(percentCPercentC_16, 0xdbff, 0xde37);
 
   934 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   918 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   935 	TEST(generatedUtf8==_L8("\xf4\x8f\xb8\xb7"));
 
   919 	test(generatedUtf8==_L8("\xf4\x8f\xb8\xb7"));
 
   936 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xde37);
 
   920 	unicode.Format(percentCPercentC_16, 0xdaaa, 0xde37);
 
   937 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   921 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   938 	TEST(generatedUtf8==_L8("\xf2\xba\xa8\xb7"));
 
   922 	test(generatedUtf8==_L8("\xf2\xba\xa8\xb7"));
 
   939 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xde37);
 
   923 	unicode.Format(percentCPercentC_16, 0xd7ff, 0xde37);
 
   940 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   924 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   941 	TEST(generatedUtf8==_L8("\xed\x9f\xbf\xed\xb8\xb7"));
 
   925 	test(generatedUtf8==_L8("\xed\x9f\xbf\xed\xb8\xb7"));
 
   942 	unicode.Format(percentCPercentC_16, 0xdc00, 0xde37);
 
   926 	unicode.Format(percentCPercentC_16, 0xdc00, 0xde37);
 
   943 	TEST(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   927 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf8, unicode)==0);
 
   944 	TEST(generatedUtf8==_L8("\xed\xb0\x80\xed\xb8\xb7"));
 
   928 	test(generatedUtf8==_L8("\xed\xb0\x80\xed\xb8\xb7"));
 
   945 	}
 
   929 	}
 
   946 	TUint i;
 
   930 	TUint i;
 
   947 	for (i=0; i<=0x1f; ++i)
 
   931 	for (i=0; i<=0x1f; ++i)
 
   948 		{
 
   932 		{
 
   949 		utf8.Format(_L8("%c%c\x99\xb1"), 0xf0|(i>>2), 0x85|((i&0x03)<<4));
 
   933 		utf8.Format(_L8("%c%c\x99\xb1"), 0xf0|(i>>2), 0x85|((i&0x03)<<4));
 
   950 		const TInt returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   934 		const TInt returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   951 		if ((i<1) || ((i-1)&~0x0f))
 
   935 		if ((i<1) || ((i-1)&~0x0f))
 
   952 			{
 
   936 			{
 
   953 			TEST(returnValue==0);
 
   937 			test(returnValue==0);
 
   954 			}
 
   938 			}
 
   955 		else
 
   939 		else
 
   956 			{
 
   940 			{
 
   957 			TEST(returnValue==0);
 
   941 			test(returnValue==0);
 
   958 			TEST(generatedUnicode.Length()==2);
 
   942 			test(generatedUnicode.Length()==2);
 
   959 			TEST((0xd815&~((i-1)<<6))==0xd815); // sanity check ((i-1)<<6)
 
   943 			test((0xd815&~((i-1)<<6))==0xd815); // sanity check ((i-1)<<6)
 
   960 			TEST(generatedUnicode[0]==(0xd815|((i-1)<<6)));
 
   944 			test(generatedUnicode[0]==(0xd815|((i-1)<<6)));
 
   961 			TEST(generatedUnicode[1]==0xde71);
 
   945 			test(generatedUnicode[1]==0xde71);
 
   962 			}
 
   946 			}
 
   963 		}
 
   947 		}
 
   964 	for (i=0; i<=0x1f; ++i)
 
   948 	for (i=0; i<=0x1f; ++i)
 
   965 		{
 
   949 		{
 
   966 		utf8.Format(_L8("%c%c\x80\x80"), 0xf0|(i>>2), 0x80|((i&0x03)<<4));
 
   950 		utf8.Format(_L8("%c%c\x80\x80"), 0xf0|(i>>2), 0x80|((i&0x03)<<4));
 
   967 		const TInt returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   951 		const TInt returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, utf8);
 
   968 		if ((i<1) || ((i-1)&~0x0f))
 
   952 		if ((i<1) || ((i-1)&~0x0f))
 
   969 			{
 
   953 			{
 
   970 			TEST(returnValue==0);
 
   954 			test(returnValue==0);
 
   971 			}
 
   955 			}
 
   972 		else
 
   956 		else
 
   973 			{
 
   957 			{
 
   974 			TEST(returnValue==0);
 
   958 			test(returnValue==0);
 
   975 			TEST(generatedUnicode.Length()==2);
 
   959 			test(generatedUnicode.Length()==2);
 
   976 			TEST((0xd800&~((i-1)<<6))==0xd800); // sanity check ((i-1)<<6)
 
   960 			test((0xd800&~((i-1)<<6))==0xd800); // sanity check ((i-1)<<6)
 
   977 			TEST(generatedUnicode[0]==(0xd800|((i-1)<<6)));
 
   961 			test(generatedUnicode[0]==(0xd800|((i-1)<<6)));
 
   978 			TEST(generatedUnicode[1]==0xdc00);
 
   962 			test(generatedUnicode[1]==0xdc00);
 
   979 			}
 
   963 			}
 
   980 		}
 
   964 		}
 
   981 	TheTest.Next(_L("Testing passing in descriptors that are empty and have NULL pointers"));
 
   965 	INFO_PRINTF1(_L("Testing passing in descriptors that are empty and have NULL pointers"));
 
   982 	enum {EBufferLength8=32};
 
   966 	enum {EBufferLength8=32};
 
   983 	TUint8 buffer8[EBufferLength8];
 
   967 	TUint8 buffer8[EBufferLength8];
 
   984 	TPtr8 null8(NULL, 0, 0);
 
   968 	TPtr8 null8(NULL, 0, 0);
 
   985 	TPtr8 trash8(REINTERPRET_CAST(TUint8*, 1), 0, 0);
 
   969 	TPtr8 trash8(REINTERPRET_CAST(TUint8*, 1), 0, 0);
 
   986 	TPtr8 empty8(buffer8, 0, EBufferLength8);
 
   970 	TPtr8 empty8(buffer8, 0, EBufferLength8);
 
  1000 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
   984 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
  1001 		const TBool inCompleteConversion8=((descriptor8.MaxLength()==0) && (descriptor16.Length()>0));
 
   985 		const TBool inCompleteConversion8=((descriptor8.MaxLength()==0) && (descriptor16.Length()>0));
 
  1002 		const TBool inCompleteConversion16=((descriptor16.MaxLength()==0) && (descriptor8.Length()>0));
 
   986 		const TBool inCompleteConversion16=((descriptor16.MaxLength()==0) && (descriptor8.Length()>0));
 
  1003 		TInt returnValue;
 
   987 		TInt returnValue;
 
  1004 		returnValue=CnvUtfConverter::ConvertFromUnicodeToUtf7(descriptor8, descriptor16, k&0x1);
 
   988 		returnValue=CnvUtfConverter::ConvertFromUnicodeToUtf7(descriptor8, descriptor16, k&0x1);
 
  1005 		TEST(inCompleteConversion8? (returnValue>0): (returnValue==0));
 
   989 		test(inCompleteConversion8? (returnValue>0): (returnValue==0));
 
  1006 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
   990 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
  1007 		returnValue=CnvUtfConverter::ConvertFromUnicodeToUtf8(descriptor8, descriptor16);
 
   991 		returnValue=CnvUtfConverter::ConvertFromUnicodeToUtf8(descriptor8, descriptor16);
 
  1008 		TEST(inCompleteConversion8? (returnValue>0): (returnValue==0));
 
   992 		test(inCompleteConversion8? (returnValue>0): (returnValue==0));
 
  1009 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
   993 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
  1010 		state=CnvUtfConverter::KStateDefault;
 
   994 		state=CnvUtfConverter::KStateDefault;
 
  1011 		returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf7(descriptor16, descriptor8, state);
 
   995 		returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf7(descriptor16, descriptor8, state);
 
  1012 		TEST(inCompleteConversion16? (returnValue>0): (returnValue==0));
 
   996 		test(inCompleteConversion16? (returnValue>0): (returnValue==0));
 
  1013 		TEST(inCompleteConversion16 || (state==CnvUtfConverter::KStateDefault));
 
   997 		test(inCompleteConversion16 || (state==CnvUtfConverter::KStateDefault));
 
  1014 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
   998 		ResetDescriptorsForNullTest(empty8, empty16, nonEmpty8, nonEmpty16);
 
  1015 		returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(descriptor16, descriptor8);
 
   999 		returnValue=CnvUtfConverter::ConvertToUnicodeFromUtf8(descriptor16, descriptor8);
 
  1016 		TEST(inCompleteConversion16? (returnValue>0): (returnValue==0));
 
  1000 		test(inCompleteConversion16? (returnValue>0): (returnValue==0));
 
  1017 		if (k&0x2)
 
  1001 		if (k&0x2)
 
  1018 			{
 
  1002 			{
 
  1019 			break;
 
  1003 			break;
 
  1020 			}
 
  1004 			}
 
  1021 		}
 
  1005 		}
 
  1022 	state=CnvUtfConverter::KStateDefault; // in case any more tests are added below
 
  1006 	state=CnvUtfConverter::KStateDefault; // in case any more tests are added below
 
  1023 
  1007 
  1024 	// Pop and destroy: unicodeHBuf, generatedUnicode, utf8, generatedUtf8
 
  1008 	// Pop and destroy: unicodeHBuf, generatedUnicode, utf8, generatedUtf8
 
  1025 	CleanupStack::PopAndDestroy(4);
 
  1009 	CleanupStack::PopAndDestroy(4);
 
  1026 	return KErrNone;
 
  1010 	}
 
  1027 	}
 
  1011 
  1028 
  1012 
  1029 
  1013 CT_ERROR::CT_ERROR()
 
  1030 GLDEF_C TInt E32Main()
 
  1014     {
 
  1031 	{
 
  1015     SetTestStepName(KTestStep_T_ERROR);
 
  1032 	__UHEAP_MARK;
 
  1016     }
 
  1033 
  1017 
  1034 	TheTest.Title();
 
  1018 TVerdict CT_ERROR::doTestStepL()
 
  1035 
  1019     {
 
  1036 	CTrapCleanup* trapCleanup=CTrapCleanup::New();
 
  1020     SetTestStepResult(EFail);
 
  1037 	TEST(trapCleanup != NULL);
 
  1021 
  1038 
  1022     __UHEAP_MARK;
 
  1039 	TRAPD(error, DoE32MainL());
 
  1023 
  1040 	TEST2(error, KErrNone);
 
  1024     TRAPD(error1, TestERROR());
 
  1041 
  1025 
  1042 	delete trapCleanup;
 
  1026     __UHEAP_MARKEND;
 
  1043 
  1027 
  1044 	TheTest.End();
 
  1028     if(error1 == KErrNone )
 
  1045 	TheTest.Close();
 
  1029         {
 
  1046 
  1030         SetTestStepResult(EPass);
 
  1047 	__UHEAP_MARKEND;
 
  1031         }
 
  1048 	return KErrNone;
 
  1032 
  1049 	}
 
  1033     return TestStepResult();
 
       
  1034     }
FCL/sf/os/textandloc