1 /* |
|
2 * Copyright (c) 1997-2009 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 #include <e32std.h> |
|
20 #include <e32base.h> |
|
21 #include <e32test.h> |
|
22 #include <f32file.h> |
|
23 #include <charconv.h> |
|
24 |
|
25 /** |
|
26 * Work around for DEF063276. |
|
27 * This literal is now loaded from a z:\test\data\KOriginalSms7Bit.dat |
|
28 * Bullseye Coverage corrupts this literal at position \x1b\x30 to \x1b\x37 |
|
29 * to avoid this literal is stored in a file as to not be touched by Bullseye Coverage. |
|
30 */ |
|
31 |
|
32 /* |
|
33 _LIT8(KOriginalSms7Bit, "\ |
|
34 \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\ |
|
35 \x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a \x1c\x1d\x1e\x1f\ |
|
36 \x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\ |
|
37 \x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\ |
|
38 \x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\ |
|
39 \x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\ |
|
40 \x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\ |
|
41 \x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\ |
|
42 \x1b\x00\x1b\x01\x1b\x02\x1b\x03\x1b\x04\x1b\x05\x1b\x06\x1b\x07\x1b\x08\x1b\x09\x1b\x0a\x1b\x0b\x1b\x0c\x1b\x0d\x1b\x0e\x1b\x0f\ |
|
43 \x1b\x10\x1b\x11\x1b\x12\x1b\x13\x1b\x14\x1b\x15\x1b\x16\x1b\x17\x1b\x18\x1b\x19\x1b\x1a\x1b\x1b\x1b\x1c\x1b\x1d\x1b\x1e\x1b\x1f\ |
|
44 \x1b\x20\x1b\x21\x1b\x22\x1b\x23\x1b\x24\x1b\x25\x1b\x26\x1b\x27\x1b\x28\x1b\x29\x1b\x2a\x1b\x2b\x1b\x2c\x1b\x2d\x1b\x2e\x1b\x2f\ |
|
45 \x1b\x30\x1b\x31\x1b\x32\x1b\x33\x1b\x34\x1b\x35\x1b\x36\x1b\x37\x1b\x38\x1b\x39\x1b\x3a\x1b\x3b\x1b\x3c\x1b\x3d\x1b\x3e\x1b\x3f\ |
|
46 \x1b\x40\x1b\x41\x1b\x42\x1b\x43\x1b\x44\x1b\x45\x1b\x46\x1b\x47\x1b\x48\x1b\x49\x1b\x4a\x1b\x4b\x1b\x4c\x1b\x4d\x1b\x4e\x1b\x4f\ |
|
47 \x1b\x50\x1b\x51\x1b\x52\x1b\x53\x1b\x54\x1b\x55\x1b\x56\x1b\x57\x1b\x58\x1b\x59\x1b\x5a\x1b\x5b\x1b\x5c\x1b\x5d\x1b\x5e\x1b\x5f\ |
|
48 \x1b\x60\x1b\x61\x1b\x62\x1b\x63\x1b\x64\x1b\x65\x1b\x67\x1b\x67\x1b\x68\x1b\x69\x1b\x6a\x1b\x6b\x1b\x6c\x1b\x6d\x1b\x6e\x1b\x6f\ |
|
49 \x1b\x70\x1b\x71\x1b\x72\x1b\x73\x1b\x74\x1b\x75\x1b\x76\x1b\x77\x1b\x78\x1b\x79\x1b\x7a\x1b\x7b\x1b\x7c\x1b\x7d\x1b\x7e\x1b\x7f"); |
|
50 */ |
|
51 |
|
52 |
|
53 _LIT8(KExpectedSms7Bit, "\ |
|
54 \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\ |
|
55 \x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a \x1c\x1d\x1e\x1f\ |
|
56 \x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\ |
|
57 \x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\ |
|
58 \x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\ |
|
59 \x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\ |
|
60 \x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\ |
|
61 \x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\ |
|
62 \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x1b\x0a\x0b\x0c\x0d\x0e\x0f\ |
|
63 \x10\x11\x12\x13\x1b\x14\x15\x16\x17\x18\x19\x1a\x3f\x1c\x1d\x1e\x1f\ |
|
64 \x20\x21\x22\x23\x24\x25\x26\x27\x1b\x28\x1b\x29\x2a\x2b\x2c\x2d\x2e\x1b\x2f\ |
|
65 \x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x1b\x3c\x1b\x3d\x1b\x3e\x3f\ |
|
66 \x1b\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\ |
|
67 \x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\ |
|
68 \x60\x61\x62\x63\x64\x1b\x65\x67\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\ |
|
69 \x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"); |
|
70 _LIT16(KExpectedUnicodeFromSms7Bit, "\ |
|
71 \x0040\x00a3$\x00a5\x00e8\x00e9\x00f9\x00ec\x00f2\x00e7\x000a\x00d8\x00f8\x000d\x00c5\x00e5\ |
|
72 \x0394\x005f\x03a6\x0393\x039b\x03a9\x03a0\x03a8\x03a3\x0398\x039e \x00c6\x00e6\x00df\x00c9\ |
|
73 \x0020!\"#\x00a4%&'()*+,-./0123456789:;<=>?\ |
|
74 \x00a1\x0041\x0042\x0043\x0044\x0045\x0046GHIJKLMNOPQRSTUVWXYZ\x00c4\x00d6\x00d1\x00dc\x00a7\ |
|
75 \x00bf\x0061\x0062\x0063\x0064\x0065\x0066ghijklmnopqrstuvwxyz\x00e4\x00f6\x00f1\x00fc\x00e0\ |
|
76 \x0040\x00a3$\x00a5\x00e8\x00e9\x00f9\x00ec\x00f2\x00c7\x000c\x00d8\x00f8\x000d\x00c5\x00e5\ |
|
77 \x0394\x005f\x03a6\x0393\x005e\x03a9\x03a0\x03a8\x03a3\x0398\x039e\xfffd\x00c6\x00e6\x00df\x00c9\ |
|
78 \x0020!\"#\x00a4%&'{}*+,-.\\0123456789:;[~]?\ |
|
79 |\x0041\x0042\x0043\x0044\x0045\x0046GHIJKLMNOPQRSTUVWXYZ\x00c4\x00d6\x00d1\x00dc\x00a7\ |
|
80 \x00bf\x0061\x0062\x0063\x0064\x20ac\x0067ghijklmnopqrstuvwxyz\x00e4\x00f6\x00f1\x00fc\x00e0"); |
|
81 |
|
82 |
|
83 |
|
84 // 1 line of the original defect data from email in unicode |
|
85 _LIT16(KEmailToConvert, "\ |
|
86 \x006C\x0069\x006E\x0065\x0020\x0065\x006E\x0064\x0073\x0020\x0069\ |
|
87 \x006E\x0020\x006A\x0061\x0070\x0061\x006E\x0065\x0073\x0065\x0020\ |
|
88 \x3075\x3064\x3059\x3057\x306B\x3072\x3080\x000d\x000a"); |
|
89 |
|
90 |
|
91 |
|
92 // the expected result when converted to ISO2022JP |
|
93 _LIT8(KExpectedIso2022jp, "\ |
|
94 \x6C\x69\x6E\x65\x20\x65\x6E\x64\x73\x20\x69\x6E\x20\ |
|
95 \x6A\x61\x70\x61\x6E\x65\x73\x65\x20\x1B\x24\x42\x24\x55\x24\x44\ |
|
96 \x24\x39\x24\x37\x24\x4B\x24\x52\x24\x60\x1B\x28\x42\x0D\x0A"); |
|
97 //\x1B\x28\x4A"); |
|
98 |
|
99 // 1 line of the original defect data from email in unicode |
|
100 _LIT16(KEmailEndingInJapanese, "\ |
|
101 \x006C\x0069\x006E\x0065\x0020\x0065\x006E\x0064\x0073\x0020\x0069\ |
|
102 \x006E\x0020\x006A\x0061\x0070\x0061\x006E\x0065\x0073\x0065\x0020\ |
|
103 \x3075\x3064\x3059\x3057\x306B\x3072\x3080"); |
|
104 |
|
105 // the expected result when converted to ISO2022JP |
|
106 _LIT8(KExpectedEmailEndingInJapanese, "\ |
|
107 \x6C\x69\x6E\x65\x20\x65\x6E\x64\x73\x20\x69\x6E\x20\ |
|
108 \x6A\x61\x70\x61\x6E\x65\x73\x65\x20\x1B\x24\x42\x24\x55\x24\x44\ |
|
109 \x24\x39\x24\x37\x24\x4B\x24\x52\x24\x60\x1B\x28\x42"); |
|
110 |
|
111 _LIT(KOriginalSms7BitFile, "z:\\test\\data\\KOriginalSms7Bit.dat"); |
|
112 |
|
113 /////////////////////////////////////////////////////////////////////////////////////// |
|
114 |
|
115 RTest TheTest(_L("TBuiltin")); |
|
116 |
|
117 /////////////////////////////////////////////////////////////////////////////////////// |
|
118 /////////////////////////////////////////////////////////////////////////////////////// |
|
119 //Tests macroses and functions. |
|
120 //If (!aValue) then the test will be panicked, the test data files will be deleted. |
|
121 static void Check(TInt aValue, TInt aLine) |
|
122 { |
|
123 if(!aValue) |
|
124 { |
|
125 TheTest(EFalse, aLine); |
|
126 } |
|
127 } |
|
128 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted. |
|
129 static void Check(TInt aValue, TInt aExpected, TInt aLine) |
|
130 { |
|
131 if(aValue != aExpected) |
|
132 { |
|
133 RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); |
|
134 TheTest(EFalse, aLine); |
|
135 } |
|
136 } |
|
137 //Use these to test conditions. |
|
138 #define TEST(arg) ::Check((arg), __LINE__) |
|
139 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) |
|
140 |
|
141 // this is the test plugin implementation ID in rather than KCharacterSetIdentifierShiftJis |
|
142 const TUint KCharacterSetTestShiftJisKddiau=0x01000001; |
|
143 |
|
144 /** |
|
145 * Utility for DEF063276 fix. |
|
146 */ |
|
147 |
|
148 static void ReadDesc(TDes8& aDes, const TDesC& aFilename, RFs& aFs) |
|
149 { |
|
150 RFile file; |
|
151 TInt err = file.Open(aFs, aFilename, EFileRead); |
|
152 TEST2(err, KErrNone); |
|
153 CleanupClosePushL(file); |
|
154 |
|
155 err = file.Read(aDes); |
|
156 TEST2(err, KErrNone); |
|
157 CleanupStack::PopAndDestroy(&file); |
|
158 } |
|
159 |
|
160 /////////////////////////////////////////////////////////////////////////////////////// |
|
161 /////////////////////////////////////////////////////////////////////////////////////// |
|
162 /** |
|
163 @SYMTestCaseID SYSLIB-CHARCONV-CT-0499 |
|
164 @SYMTestCaseDesc Tests for conversion of SMS 7 bit data to Unicode, and from Unicode to original data |
|
165 @SYMTestPriority Medium |
|
166 @SYMTestActions Tests for CCnvCharacterSetConverter::ConvertToUnicode(),CCnvCharacterSetConverter::ConvertFromUnicode() |
|
167 @SYMTestExpectedResults Test must not fail |
|
168 @SYMREQ REQ0000 |
|
169 */ |
|
170 void TestFix_EDNJJUN_4RWH2A(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession, CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aArrayOfCharacterSetsAvailable) |
|
171 { |
|
172 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0499 ")); |
|
173 TBuf16<300> generatedUnicode; |
|
174 TBuf8<300> generatedSms7Bit; |
|
175 TRAPD(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
176 TEST2(errCode, KErrNone); |
|
177 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
178 |
|
179 // Fix for DEF063276. |
|
180 |
|
181 TBuf8<400> buf; |
|
182 ReadDesc(buf, KOriginalSms7BitFile, aFileServerSession); |
|
183 |
|
184 TEST(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, buf, state)==0); |
|
185 // End fix. |
|
186 |
|
187 TEST(generatedUnicode.Length()==259); |
|
188 TEST(generatedUnicode==KExpectedUnicodeFromSms7Bit); |
|
189 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
190 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedSms7Bit, generatedUnicode)==0); |
|
191 TEST(generatedSms7Bit.Length()==269); |
|
192 TEST(generatedSms7Bit==KExpectedSms7Bit); |
|
193 } |
|
194 |
|
195 /** |
|
196 Test_DEF049749 test code for DEF049749 - Char convs don t handle correcly Shift JIS emoji |
|
197 |
|
198 @SYMTestCaseID SYSLIB-CHARCONV-CT-0500 |
|
199 @SYMTestCaseDesc Tests for defect number DEF049749 |
|
200 @SYMTestPriority Medium |
|
201 @SYMTestActions Tests for conversion from Shift JIS Emoji character set to Unicode |
|
202 Tests for CCnvCharacterSetConverter::EErrorIllFormedInput error flag |
|
203 @SYMTestExpectedResults Test must not fail |
|
204 @SYMREQ REQ0000 |
|
205 */ |
|
206 void Test_DEF049749(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession, CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aArrayOfCharacterSetsAvailable) |
|
207 { |
|
208 // original defect data |
|
209 _LIT8(KCodeToConvert, "\xF8\x9F\xF8\x9F\x81\x40\x3B\x3B\x3B\x3B"); |
|
210 _LIT16(KExpectedUnicode, "\xFFFD\xFFFD\x3000\x003b\x003b\x003b\x003b"); |
|
211 TBuf16<300> generatedUnicode; |
|
212 |
|
213 // check now able to convert the original defect data |
|
214 TRAPD(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
215 TEST2(errCode, KErrNone); |
|
216 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
217 TInt ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KCodeToConvert, state); |
|
218 |
|
219 // in DEF049749 CCnvCharacterSetConverter::EErrorIllFormedInput was incorrectly returned. |
|
220 // rather than the number of unconverted bytes left, which should be 0 |
|
221 TEST(ret ==0); |
|
222 TEST(generatedUnicode==KExpectedUnicode); |
|
223 |
|
224 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0500 User-defined ShiftJIS region->FFFD ")); |
|
225 /* check the user defined region (ref CJKV Ken Lunde page206) |
|
226 F040-F97E and F080-F9FC */ |
|
227 TBuf8<300> sampleUserDefined; |
|
228 for (TInt leadByte = 0xF0; leadByte != 0xF9; leadByte++) |
|
229 { |
|
230 // a leadbyte missing the trail byte then another character |
|
231 sampleUserDefined.Format(_L8("%c\x3F"), leadByte); |
|
232 _LIT16(KExpectedUnicode4, "\xFFFD\x3F"); |
|
233 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
234 TEST2(errCode, KErrNone); |
|
235 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
236 TEST(ret ==0); |
|
237 TEST(generatedUnicode==KExpectedUnicode4); |
|
238 |
|
239 // a single leadbyte missing the trail byte |
|
240 sampleUserDefined.Format(_L8("%c"), leadByte); |
|
241 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
242 TEST2(errCode, KErrNone); |
|
243 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
244 TEST(ret == CCnvCharacterSetConverter::EErrorIllFormedInput); |
|
245 |
|
246 // Default version of Shift-JIS converter now contains mappings for ezweb private use |
|
247 // in range 0xF7BC to 0xF7FC so following tests would fail in this area - JG 30/06/2005 |
|
248 if ((leadByte < 0xF3) || (leadByte > 0xF7)) |
|
249 { |
|
250 for (TInt trailbyte = 0x40; trailbyte != 0xFD; |
|
251 trailbyte += (trailbyte == 0x7E? 2 : 1)) |
|
252 { |
|
253 TInt errCode = KErrNone; |
|
254 |
|
255 // emoji character on its own |
|
256 sampleUserDefined.Format(_L8("%c%c"), leadByte, trailbyte); |
|
257 _LIT16(KExpectedUnicode1, "\xFFFD"); |
|
258 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
259 TEST2(errCode, KErrNone); |
|
260 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
261 TEST(ret ==0); |
|
262 TEST(generatedUnicode==KExpectedUnicode1); |
|
263 |
|
264 // followed by a single character |
|
265 sampleUserDefined.Format(_L8("%c%cx"), leadByte, trailbyte); |
|
266 _LIT16(KExpectedUnicode2, "\xFFFDx"); |
|
267 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
268 TEST2(errCode, KErrNone); |
|
269 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
270 TEST(ret ==0); |
|
271 TEST(generatedUnicode==KExpectedUnicode2); |
|
272 |
|
273 // preceeded by a single character |
|
274 sampleUserDefined.Format(_L8("x%c%c"), leadByte, trailbyte); |
|
275 _LIT16(KExpectedUnicode3, "x\xFFFD"); |
|
276 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
277 TEST2(errCode, KErrNone); |
|
278 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
279 TEST(ret ==0); |
|
280 TEST(generatedUnicode==KExpectedUnicode3); |
|
281 } |
|
282 } |
|
283 } |
|
284 |
|
285 TheTest.Next(_L("All double-byte characters convert to single Unicode")); |
|
286 TText8 LeadBytes[] = { 0x81, 0x9F, 0xE0, 0xEA, 0xEB, 0xF9, 0xFA, 0xFC }; |
|
287 TText8 TrailBytes[] = { 0x40, 0x7E, 0x80, 0xFC }; |
|
288 TText8* leadp; |
|
289 for (leadp = LeadBytes; |
|
290 leadp != LeadBytes + sizeof(LeadBytes)/sizeof(LeadBytes[0]); |
|
291 ++leadp) |
|
292 { |
|
293 // a single leadbyte missing the trail byte |
|
294 sampleUserDefined.Format(_L8("%c"), *leadp); |
|
295 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
296 TEST2(errCode, KErrNone); |
|
297 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
298 TEST(ret == CCnvCharacterSetConverter::EErrorIllFormedInput); |
|
299 |
|
300 // lead byte then illegal trail byte, which is a legal byte on its own |
|
301 sampleUserDefined.Format(_L8("%c%c"), *leadp, 0x3F); |
|
302 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
303 TEST2(errCode, KErrNone); |
|
304 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
305 TEST(ret == 0); |
|
306 TEST(generatedUnicode == _L16("\xFFFD\x3F")); |
|
307 |
|
308 for (TText8* trailp = TrailBytes; |
|
309 trailp != TrailBytes + sizeof(TrailBytes)/sizeof(TrailBytes[0]); |
|
310 ++trailp) |
|
311 { |
|
312 sampleUserDefined.Format(_L8("%c%c"), *leadp, *trailp); |
|
313 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
314 TEST2(errCode, KErrNone); |
|
315 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
316 TEST(ret == 0); |
|
317 TEST(generatedUnicode.Length() == 1); |
|
318 } |
|
319 } |
|
320 |
|
321 TheTest.Next(_L("All single-byte characters convert to single Unicode")); |
|
322 TText8 SingleBytes[] = { 0, 0x7F, 0x80, 0xA0, 0xA1, 0xFD, 0xFE, 0xFF }; |
|
323 for (TText8* singlep = SingleBytes; |
|
324 singlep != SingleBytes + sizeof(SingleBytes)/sizeof(SingleBytes[0]); |
|
325 ++singlep) |
|
326 { |
|
327 // a single leadbyte missing the trail byte |
|
328 sampleUserDefined.Format(_L8("%c"), *singlep); |
|
329 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
330 TEST2(errCode, KErrNone); |
|
331 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
332 TEST(ret == 0); |
|
333 TEST(generatedUnicode.Length() == 1); |
|
334 } |
|
335 |
|
336 TheTest.Next(_L("Valid lead byte + invalid trail byte -> FFFD + something")); |
|
337 TText8 NotTrailBytes[] = { 0x3F, 0x7F, 0xFD, 0xFE, 0xFF }; |
|
338 for (leadp = LeadBytes; |
|
339 leadp != LeadBytes + sizeof(LeadBytes)/sizeof(LeadBytes[0]); |
|
340 ++leadp) |
|
341 { |
|
342 for (TText8* trailp = NotTrailBytes; |
|
343 trailp != NotTrailBytes + sizeof(NotTrailBytes)/sizeof(NotTrailBytes[0]); |
|
344 ++trailp) |
|
345 { |
|
346 sampleUserDefined.Format(_L8("%c%c"), *leadp, *trailp); |
|
347 TRAP(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetTestShiftJisKddiau, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
348 TEST2(errCode, KErrNone); |
|
349 ret = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, sampleUserDefined, state); |
|
350 TEST(ret == 0); |
|
351 TEST(generatedUnicode.Length() == 2); |
|
352 TEST(generatedUnicode[0] == 0xFFFD); |
|
353 } |
|
354 } |
|
355 } |
|
356 |
|
357 /** |
|
358 Test_DEF053900 test code for DEF053900 - Problems encoding Japanese emails to ISO-2022-JP |
|
359 |
|
360 @SYMTestCaseID SYSLIB-CHARCONV-CT-1306 |
|
361 @SYMTestCaseDesc Tests for defect number DEF053900 |
|
362 @SYMTestPriority Medium |
|
363 @SYMTestActions Attempt for converting from Japanese character set email to Unicode. |
|
364 @SYMTestExpectedResults Test must not fail |
|
365 @SYMREQ REQ0000 |
|
366 */ |
|
367 void Test_DEF053900(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession, CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aArrayOfCharacterSetsAvailable) |
|
368 { |
|
369 // check now able to convert the original defect data |
|
370 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-1306 ")); |
|
371 TBuf8<300> generatedIso2022; |
|
372 TRAPD(errCode, aCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierIso2022Jp, aArrayOfCharacterSetsAvailable, aFileServerSession)); |
|
373 TEST2(errCode, KErrNone); |
|
374 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
375 TInt ret = aCharacterSetConverter.ConvertFromUnicode(generatedIso2022, KEmailToConvert, state); |
|
376 // check the converted data is as expected |
|
377 TEST(ret ==0); |
|
378 TEST(generatedIso2022==KExpectedIso2022jp); |
|
379 ret = aCharacterSetConverter.ConvertFromUnicode(generatedIso2022, KEmailEndingInJapanese, state); |
|
380 TEST(ret ==0); |
|
381 TEST(generatedIso2022==KExpectedEmailEndingInJapanese); |
|
382 } |
|
383 |
|
384 /** |
|
385 @SYMTestCaseID SYSLIB-CHARCONV-CT-0501 |
|
386 @SYMTestCaseDesc Tests for CCnvCharacterSetConverter class |
|
387 @SYMTestPriority Medium |
|
388 @SYMTestActions Tests for conversion from empty descriptors to different character sets |
|
389 @SYMTestExpectedResults Test must not fail |
|
390 @SYMREQ REQ0000 |
|
391 */ |
|
392 LOCAL_C void DoE32MainL() |
|
393 { |
|
394 RFs fileServerSession; |
|
395 CleanupClosePushL(fileServerSession); |
|
396 User::LeaveIfError(fileServerSession.Connect()); |
|
397 CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC(); |
|
398 CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession); |
|
399 TheTest.Printf(_L("Available:\n")); |
|
400 for (TInt i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i) |
|
401 { |
|
402 const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i]; |
|
403 characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession); |
|
404 TPtrC charactersSetName(charactersSet.Name()); |
|
405 if (charactersSet.NameIsFileName()) |
|
406 { |
|
407 charactersSetName.Set(TParsePtrC(charactersSetName).Name()); |
|
408 } |
|
409 TheTest.Printf(_L(" %S\n"), &charactersSetName); |
|
410 } |
|
411 TBuf16<128> originalUnicode; |
|
412 TBuf8<128> generatedForeign; |
|
413 TBuf16<128> generatedUnicode; |
|
414 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
415 TUint characterCode; |
|
416 TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0501 Testing empty descriptors (Code Page 1252) ")); |
|
417 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
418 originalUnicode=KNullDesC16; |
|
419 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
420 TEST(generatedForeign==KNullDesC8); |
|
421 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
422 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
423 TEST(generatedUnicode==originalUnicode); |
|
424 TheTest.Next(_L("Testing empty descriptors (ISO-8859-1)")); |
|
425 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierIso88591, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
426 originalUnicode=KNullDesC16; |
|
427 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
428 TEST(generatedForeign==KNullDesC8); |
|
429 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
430 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
431 TEST(generatedUnicode==originalUnicode); |
|
432 TheTest.Next(_L("Testing empty descriptors (ASCII)")); |
|
433 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierAscii, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
434 originalUnicode=KNullDesC16; |
|
435 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
436 TEST(generatedForeign==KNullDesC8); |
|
437 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
438 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
439 TEST(generatedUnicode==originalUnicode); |
|
440 TheTest.Next(_L("Testing empty descriptors (SMS 7-bit)")); |
|
441 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
442 originalUnicode=KNullDesC16; |
|
443 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
444 TEST(generatedForeign==KNullDesC8); |
|
445 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
446 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
447 TEST(generatedUnicode==originalUnicode); |
|
448 TheTest.Next(_L("Testing exhaustive single-character Code Page 1252 round trips")); |
|
449 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
450 for (characterCode=0x00; characterCode<=0x7f; ++characterCode) |
|
451 { |
|
452 originalUnicode.Format(_L16("%c"), characterCode); |
|
453 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
454 TBuf8<1> expectedForeign; |
|
455 expectedForeign.Format(_L8("%c"), characterCode); |
|
456 TEST(generatedForeign==expectedForeign); |
|
457 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
458 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
459 TEST(generatedUnicode==originalUnicode); |
|
460 } |
|
461 originalUnicode.Format(_L16("%c"), 0x20ac); |
|
462 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
463 TEST(generatedForeign==_L8("\x80")); |
|
464 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
465 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
466 TEST(generatedUnicode==originalUnicode); |
|
467 originalUnicode.Format(_L16("%c"), 0x201a); |
|
468 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
469 TEST(generatedForeign==_L8("\x82")); |
|
470 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
471 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
472 TEST(generatedUnicode==originalUnicode); |
|
473 originalUnicode.Format(_L16("%c"), 0x0192); |
|
474 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
475 TEST(generatedForeign==_L8("\x83")); |
|
476 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
477 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
478 TEST(generatedUnicode==originalUnicode); |
|
479 originalUnicode.Format(_L16("%c"), 0x201e); |
|
480 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
481 TEST(generatedForeign==_L8("\x84")); |
|
482 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
483 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
484 TEST(generatedUnicode==originalUnicode); |
|
485 originalUnicode.Format(_L16("%c"), 0x2026); |
|
486 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
487 TEST(generatedForeign==_L8("\x85")); |
|
488 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
489 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
490 TEST(generatedUnicode==originalUnicode); |
|
491 originalUnicode.Format(_L16("%c"), 0x2020); |
|
492 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
493 TEST(generatedForeign==_L8("\x86")); |
|
494 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
495 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
496 TEST(generatedUnicode==originalUnicode); |
|
497 originalUnicode.Format(_L16("%c"), 0x2021); |
|
498 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
499 TEST(generatedForeign==_L8("\x87")); |
|
500 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
501 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
502 TEST(generatedUnicode==originalUnicode); |
|
503 originalUnicode.Format(_L16("%c"), 0x02c6); |
|
504 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
505 TEST(generatedForeign==_L8("\x88")); |
|
506 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
507 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
508 TEST(generatedUnicode==originalUnicode); |
|
509 originalUnicode.Format(_L16("%c"), 0x2030); |
|
510 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
511 TEST(generatedForeign==_L8("\x89")); |
|
512 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
513 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
514 TEST(generatedUnicode==originalUnicode); |
|
515 originalUnicode.Format(_L16("%c"), 0x0160); |
|
516 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
517 TEST(generatedForeign==_L8("\x8a")); |
|
518 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
519 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
520 TEST(generatedUnicode==originalUnicode); |
|
521 originalUnicode.Format(_L16("%c"), 0x2039); |
|
522 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
523 TEST(generatedForeign==_L8("\x8b")); |
|
524 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
525 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
526 TEST(generatedUnicode==originalUnicode); |
|
527 originalUnicode.Format(_L16("%c"), 0x0152); |
|
528 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
529 TEST(generatedForeign==_L8("\x8c")); |
|
530 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
531 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
532 TEST(generatedUnicode==originalUnicode); |
|
533 originalUnicode.Format(_L16("%c"), 0x017d); |
|
534 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
535 TEST(generatedForeign==_L8("\x8e")); |
|
536 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
537 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
538 TEST(generatedUnicode==originalUnicode); |
|
539 originalUnicode.Format(_L16("%c"), 0x017e); |
|
540 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
541 TEST(generatedForeign==_L8("\x9e")); |
|
542 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
543 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
544 TEST(generatedUnicode==originalUnicode); |
|
545 originalUnicode.Format(_L16("%c"), 0x2018); |
|
546 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
547 TEST(generatedForeign==_L8("\x91")); |
|
548 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
549 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
550 TEST(generatedUnicode==originalUnicode); |
|
551 originalUnicode.Format(_L16("%c"), 0x2019); |
|
552 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
553 TEST(generatedForeign==_L8("\x92")); |
|
554 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
555 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
556 TEST(generatedUnicode==originalUnicode); |
|
557 originalUnicode.Format(_L16("%c"), 0x201c); |
|
558 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
559 TEST(generatedForeign==_L8("\x93")); |
|
560 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
561 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
562 TEST(generatedUnicode==originalUnicode); |
|
563 originalUnicode.Format(_L16("%c"), 0x201d); |
|
564 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
565 TEST(generatedForeign==_L8("\x94")); |
|
566 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
567 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
568 TEST(generatedUnicode==originalUnicode); |
|
569 originalUnicode.Format(_L16("%c"), 0x2022); |
|
570 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
571 TEST(generatedForeign==_L8("\x95")); |
|
572 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
573 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
574 TEST(generatedUnicode==originalUnicode); |
|
575 originalUnicode.Format(_L16("%c"), 0x2013); |
|
576 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
577 TEST(generatedForeign==_L8("\x96")); |
|
578 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
579 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
580 TEST(generatedUnicode==originalUnicode); |
|
581 originalUnicode.Format(_L16("%c"), 0x2014); |
|
582 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
583 TEST(generatedForeign==_L8("\x97")); |
|
584 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
585 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
586 TEST(generatedUnicode==originalUnicode); |
|
587 originalUnicode.Format(_L16("%c"), 0x02dc); |
|
588 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
589 TEST(generatedForeign==_L8("\x98")); |
|
590 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
591 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
592 TEST(generatedUnicode==originalUnicode); |
|
593 originalUnicode.Format(_L16("%c"), 0x2122); |
|
594 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
595 TEST(generatedForeign==_L8("\x99")); |
|
596 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
597 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
598 TEST(generatedUnicode==originalUnicode); |
|
599 originalUnicode.Format(_L16("%c"), 0x0161); |
|
600 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
601 TEST(generatedForeign==_L8("\x9a")); |
|
602 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
603 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
604 TEST(generatedUnicode==originalUnicode); |
|
605 originalUnicode.Format(_L16("%c"), 0x203a); |
|
606 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
607 TEST(generatedForeign==_L8("\x9b")); |
|
608 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
609 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
610 TEST(generatedUnicode==originalUnicode); |
|
611 originalUnicode.Format(_L16("%c"), 0x0153); |
|
612 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
613 TEST(generatedForeign==_L8("\x9c")); |
|
614 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
615 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
616 TEST(generatedUnicode==originalUnicode); |
|
617 originalUnicode.Format(_L16("%c"), 0x0178); |
|
618 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
619 TEST(generatedForeign==_L8("\x9f")); |
|
620 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
621 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
622 TEST(generatedUnicode==originalUnicode); |
|
623 for (characterCode=0xa0; characterCode<0xff; ++characterCode) |
|
624 { |
|
625 originalUnicode.Format(_L16("%c"), characterCode); |
|
626 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
627 TBuf8<1> expectedForeign; |
|
628 expectedForeign.Format(_L8("%c"), characterCode); |
|
629 TEST(generatedForeign==expectedForeign); |
|
630 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
631 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
632 TEST(generatedUnicode==originalUnicode); |
|
633 } |
|
634 TheTest.Next(_L("Testing exhaustive single-character ISO-8859-1 round trips")); |
|
635 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierIso88591, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
636 for (characterCode=0x00; characterCode<=0xff; ++characterCode) |
|
637 { |
|
638 const TBool unconvertibleCharacter=(characterCode==0x80); |
|
639 TInt numberOfUnconvertibleCharacters; |
|
640 TInt indexOfFirstUnconvertibleCharacter; |
|
641 originalUnicode.Format(_L16("%c"), characterCode); |
|
642 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode, numberOfUnconvertibleCharacters, indexOfFirstUnconvertibleCharacter)==0); |
|
643 if (characterCode != 0x80) |
|
644 TEST(numberOfUnconvertibleCharacters==(unconvertibleCharacter? 1: 0)); |
|
645 if (numberOfUnconvertibleCharacters>0) |
|
646 { |
|
647 TEST(indexOfFirstUnconvertibleCharacter==0); |
|
648 } |
|
649 TBuf8<1> expectedForeign; |
|
650 expectedForeign.Format(_L8("%c"), unconvertibleCharacter? 0x1a: characterCode); |
|
651 TEST(generatedForeign==expectedForeign); |
|
652 TBuf8<1> originalForeign; |
|
653 originalForeign.Format(_L8("%c"), characterCode); |
|
654 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, originalForeign, state, numberOfUnconvertibleCharacters, indexOfFirstUnconvertibleCharacter)==0); |
|
655 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
656 if (characterCode != 0x80) |
|
657 TEST(numberOfUnconvertibleCharacters==(unconvertibleCharacter? 1: 0)); |
|
658 if (numberOfUnconvertibleCharacters>0) |
|
659 { |
|
660 TEST(indexOfFirstUnconvertibleCharacter==0); |
|
661 } |
|
662 if (unconvertibleCharacter) |
|
663 { |
|
664 TEST(generatedUnicode.Length()==1); |
|
665 if (characterCode==0x80) |
|
666 TEST(generatedUnicode[0]==0x20ac); |
|
667 else |
|
668 TEST(generatedUnicode[0]==0xfffd); |
|
669 } |
|
670 else |
|
671 { |
|
672 TEST(generatedUnicode==originalUnicode); |
|
673 } |
|
674 } |
|
675 TheTest.Next(_L("Testing exhaustive single-character ASCII round trips")); |
|
676 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierAscii, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
677 for (characterCode=0x00; characterCode<=0xff; ++characterCode) |
|
678 { |
|
679 const TBool unconvertibleCharacter=(characterCode>=0x80); |
|
680 TInt numberOfUnconvertibleCharacters; |
|
681 originalUnicode.Format(_L16("%c"), characterCode); |
|
682 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode, numberOfUnconvertibleCharacters)==0); |
|
683 TEST(numberOfUnconvertibleCharacters==(unconvertibleCharacter? 1: 0)); |
|
684 TBuf8<1> expectedForeign; |
|
685 expectedForeign.Format(_L8("%c"), unconvertibleCharacter? 0x1a: characterCode); |
|
686 TEST(generatedForeign==expectedForeign); |
|
687 TBuf8<1> originalForeign; |
|
688 originalForeign.Format(_L8("%c"), characterCode); |
|
689 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, originalForeign, state, numberOfUnconvertibleCharacters)==0); |
|
690 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
691 TEST(numberOfUnconvertibleCharacters==(unconvertibleCharacter? 1: 0)); |
|
692 if (unconvertibleCharacter) |
|
693 { |
|
694 TEST(generatedUnicode.Length()==1); |
|
695 TEST(generatedUnicode[0]==0xfffd); |
|
696 } |
|
697 else |
|
698 { |
|
699 TEST(generatedUnicode==originalUnicode); |
|
700 } |
|
701 } |
|
702 TheTest.Next(_L("Testing exhaustive SMS 7-bit round trip (default table)")); |
|
703 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, fileServerSession); |
|
704 originalUnicode.SetLength(0); |
|
705 const TPtrC16 formatOfSixteenCharacters=_L16("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"); |
|
706 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0040, 0x00a3, 0x0024, 0x00a5, 0x00e8, 0x00e9, 0x00f9, 0x00ec, 0x00f2, 0x00e7, 0x000a, 0x00d8, 0x00f8, 0x000d, 0x00c5, 0x00e5); |
|
707 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0394, 0x005f, 0x03a6, 0x0393, 0x039b, 0x03a9, 0x03a0, 0x03a8, 0x03a3, 0x0398, 0x039e, '!', 0x00c6, 0x00e6, 0x00df, 0x00c9); |
|
708 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0020, 0x0021, 0x0022, 0x0023, 0x00a4, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f); |
|
709 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f); |
|
710 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x00a1, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f); |
|
711 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x00c4, 0x00d6, 0x00d1, 0x00dc, 0x00a7); |
|
712 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x00bf, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f); |
|
713 originalUnicode.AppendFormat(formatOfSixteenCharacters, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x00e4, 0x00f6, 0x00f1, 0x00fc, 0x00e0); |
|
714 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
715 TEST(generatedForeign.Length()==0x80); |
|
716 for (characterCode=0x00; characterCode<0x80; ++characterCode) |
|
717 { |
|
718 TEST(generatedForeign[characterCode]==(characterCode==0x1b)? '!': characterCode); |
|
719 } |
|
720 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
721 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
722 TEST(generatedUnicode==originalUnicode); |
|
723 TheTest.Next(_L("Testing Greek range of SMS 7-bit")); |
|
724 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
725 TBuf16<16> expectedUnicode; |
|
726 originalUnicode.Format(formatOfSixteenCharacters.Left(7*2), 0x0386, 0x0388, 0x0389, 0x038a, 0x038c, 0x038e, 0x038f); |
|
727 expectedUnicode.Format(formatOfSixteenCharacters.Left(7*2), 0x0041, 0x0045, 0x0048, 0x0049, 0x004f, 0x0059, 0x03a9); |
|
728 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
729 TEST(generatedForeign==_L8("\x41\x45\x48\x49\x4f\x59\x15")); |
|
730 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
731 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
732 TEST(generatedUnicode==expectedUnicode); |
|
733 originalUnicode.Format(formatOfSixteenCharacters, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f); |
|
734 expectedUnicode.Format(formatOfSixteenCharacters, 0x0049, 0x0041, 0x0042, 0x0393, 0x0394, 0x0045, 0x005a, 0x0048, 0x0398, 0x0049, 0x004b, 0x039b, 0x004d, 0x004e, 0x039e, 0x004f); |
|
735 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
736 TEST(generatedForeign==_L8("\x49\x41\x42\x13\x10\x45\x5a\x48\x19\x49\x4b\x14\x4d\x4e\x1a\x4f")); |
|
737 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
738 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
739 TEST(generatedUnicode==expectedUnicode); |
|
740 originalUnicode.Format(formatOfSixteenCharacters.Left(15*2), 0x03a0, 0x03a1, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af); |
|
741 expectedUnicode.Format(formatOfSixteenCharacters.Left(15*2), 0x03a0, 0x0050, 0x03a3, 0x0054, 0x0059, 0x03a6, 0x0058, 0x03a8, 0x03a9, 0x0049, 0x0059, 0x0041, 0x0045, 0x0048, 0x0049); |
|
742 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
743 TEST(generatedForeign==_L8("\x16\x50\x18\x54\x59\x12\x58\x17\x15\x49\x59\x41\x45\x48\x49")); |
|
744 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
745 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
746 TEST(generatedUnicode==expectedUnicode); |
|
747 originalUnicode.Format(formatOfSixteenCharacters, 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf); |
|
748 expectedUnicode.Format(formatOfSixteenCharacters, 0x0059, 0x0041, 0x0042, 0x0393, 0x0394, 0x0045, 0x005a, 0x0048, 0x0398, 0x0049, 0x004b, 0x039b, 0x004d, 0x004e, 0x039e, 0x004f); |
|
749 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
750 TEST(generatedForeign==_L8("\x59\x41\x42\x13\x10\x45\x5a\x48\x19\x49\x4b\x14\x4d\x4e\x1a\x4f")); |
|
751 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
752 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
753 TEST(generatedUnicode==expectedUnicode); |
|
754 originalUnicode.Format(formatOfSixteenCharacters.Left(15*2), 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce); |
|
755 expectedUnicode.Format(formatOfSixteenCharacters.Left(15*2), 0x03a0, 0x0050, 0x03a3, 0x03a3, 0x0054, 0x0059, 0x03a6, 0x0058, 0x03a8, 0x03a9, 0x0049, 0x0059, 0x004f, 0x0059, 0x03a9); |
|
756 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
757 TEST(generatedForeign==_L8("\x16\x50\x18\x18\x54\x59\x12\x58\x17\x15\x49\x59\x4f\x59\x15")); |
|
758 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
759 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
760 TEST(generatedUnicode==expectedUnicode); |
|
761 originalUnicode.Format(formatOfSixteenCharacters.Left(6*2), 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5); |
|
762 expectedUnicode.Format(formatOfSixteenCharacters.Left(6*2), 0x0042, 0x0398, 0x0059, 0x0059, 0x0059, 0x03a6); |
|
763 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
764 TEST(generatedForeign==_L8("\x42\x19\x59\x59\x59\x12")); |
|
765 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
766 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
767 TEST(generatedUnicode==expectedUnicode); |
|
768 { |
|
769 TheTest.Next(_L("Testing converting from Internet-standard names to UIDs")); |
|
770 TEST(characterSetConverter->ConvertStandardNameOfCharacterSetToIdentifierL(_L8("US-ASCII"), fileServerSession)==KCharacterSetIdentifierAscii); |
|
771 HBufC8* standardName=characterSetConverter->ConvertCharacterSetIdentifierToStandardNameL(KCharacterSetIdentifierAscii, fileServerSession); |
|
772 TEST(*standardName==_L8("US-ASCII")); |
|
773 delete standardName; |
|
774 } |
|
775 { |
|
776 TheTest.Next(_L("Testing fix for defect EDNEMUA-4KGFEY in \"Symbian Defect Tracking v3.0\"")); |
|
777 CCnvCharacterSetConverter* characterSetConverter2=CCnvCharacterSetConverter::NewLC(); |
|
778 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
779 characterSetConverter2->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
780 characterSetConverter2->SetDowngradeForExoticLineTerminatingCharacters(CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed); |
|
781 originalUnicode.Format(_L16("Line1%cLine2%cLine3\x0aLine4\x0d\x0a"), 0x2029, 0x2028); |
|
782 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
783 TEST(generatedForeign==_L8("Line1\x0d\x0aLine2\x0d\x0aLine3\x0aLine4\x0d\x0a")); |
|
784 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
785 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
786 TEST(generatedUnicode==_L16("Line1\x0d\x0aLine2\x0d\x0aLine3\x0aLine4\x0d\x0a")); |
|
787 TEST(characterSetConverter2->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
788 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
789 TEST(generatedUnicode==_L16("Line1\x0d\x0aLine2\x0d\x0aLine3\x0aLine4\x0d\x0a")); |
|
790 TEST(characterSetConverter2->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
791 TEST(generatedForeign==_L8("Line1\x0aLine2\x0aLine3\x0aLine4\x0d\x0a")); |
|
792 TEST(characterSetConverter2->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
793 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
794 TEST(generatedUnicode==_L16("Line1\x0aLine2\x0aLine3\x0aLine4\x0d\x0a")); |
|
795 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
796 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
797 TEST(generatedUnicode==_L16("Line1\x0aLine2\x0aLine3\x0aLine4\x0d\x0a")); |
|
798 CleanupStack::PopAndDestroy(); // characterSetConverter2 |
|
799 } |
|
800 { |
|
801 TheTest.Next(_L("Testing fix for defect EDNPSTN-4L5K2G in \"Symbian Defect Tracking v3.0\" (i.e. the extension table)")); |
|
802 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
803 originalUnicode.Format(_L16("%c^{}\\abc[~]|%c"), 0x000c, 0x20ac); |
|
804 TEST(characterSetConverter->ConvertFromUnicode(generatedForeign, originalUnicode)==0); |
|
805 TEST(generatedForeign==_L8("\x1b\x0a\x1b\x14\x1b\x28\x1b\x29\x1b\x2f""abc\x1b\x3c\x1b\x3d\x1b\x3e\x1b\x40\x1b\x65")); |
|
806 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state)==0); |
|
807 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
808 TEST(generatedUnicode==originalUnicode); |
|
809 } |
|
810 { |
|
811 TheTest.Next(_L("Testing fix for defect EDNJJUN-4RWH2A in \"Symbian Defect Tracking v3.0\" (SMS 7-bit [0x1b, 0x41] should be converted to 0x0041, etc.)")); |
|
812 TestFix_EDNJJUN_4RWH2A(*characterSetConverter, fileServerSession, *arrayOfCharacterSetsAvailable); |
|
813 } |
|
814 |
|
815 // |
|
816 TheTest.Next(_L("Testing fix for defect DEF049749")); |
|
817 Test_DEF049749(*characterSetConverter, fileServerSession, *arrayOfCharacterSetsAvailable); |
|
818 |
|
819 TheTest.Next(_L("Testing fix for defect DEF053900")); |
|
820 Test_DEF053900(*characterSetConverter, fileServerSession, *arrayOfCharacterSetsAvailable); |
|
821 |
|
822 CleanupStack::PopAndDestroy(3); // arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession |
|
823 } |
|
824 |
|
825 GLDEF_C TInt E32Main() |
|
826 { |
|
827 __UHEAP_MARK; |
|
828 |
|
829 TheTest.Title(); |
|
830 |
|
831 CTrapCleanup* trapCleanup=CTrapCleanup::New(); |
|
832 TEST(trapCleanup != NULL); |
|
833 |
|
834 TRAPD(error, DoE32MainL()); |
|
835 TEST2(error, KErrNone); |
|
836 |
|
837 delete trapCleanup; |
|
838 |
|
839 TheTest.End(); |
|
840 TheTest.Close(); |
|
841 |
|
842 __UHEAP_MARKEND; |
|
843 return KErrNone; |
|
844 } |
|