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