|
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 the License "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 <e32base.h> |
|
27 #include <e32test.h> |
|
28 #include <f32file.h> |
|
29 #include <charconv.h> |
|
30 |
|
31 /////////////////////////////////////////////////////////////////////////////////////// |
|
32 |
|
33 RTest TheTest(_L("TGBK")); |
|
34 |
|
35 /////////////////////////////////////////////////////////////////////////////////////// |
|
36 /////////////////////////////////////////////////////////////////////////////////////// |
|
37 //Tests macroses and functions. |
|
38 //If (!aValue) then the test will be panicked, the test data files will be deleted. |
|
39 static void Check(TInt aValue, TInt aLine) |
|
40 { |
|
41 if(!aValue) |
|
42 { |
|
43 TheTest(EFalse, aLine); |
|
44 } |
|
45 } |
|
46 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted. |
|
47 static void Check(TInt aValue, TInt aExpected, TInt aLine) |
|
48 { |
|
49 if(aValue != aExpected) |
|
50 { |
|
51 RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); |
|
52 TheTest(EFalse, aLine); |
|
53 } |
|
54 } |
|
55 //Use these to test conditions. |
|
56 #define TEST(arg) ::Check((arg), __LINE__) |
|
57 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) |
|
58 |
|
59 /////////////////////////////////////////////////////////////////////////////////////// |
|
60 /////////////////////////////////////////////////////////////////////////////////////// |
|
61 |
|
62 |
|
63 const TInt KMibValue = 113; |
|
64 const TInt KBufferLength=100; |
|
65 /** |
|
66 @SYMTestCaseID SYSLIB-CHARCONV-CT-0509 |
|
67 @SYMTestCaseDesc Tests for truncated conversion from Unicode to GBK |
|
68 @SYMTestPriority Medium |
|
69 @SYMTestActions Tests for truncated conversion from Unicode to Gbk and back to Unicode. |
|
70 Tests for the generated Unicode with original Unicode |
|
71 @SYMTestExpectedResults Test must not fail |
|
72 @SYMREQ REQ0000 |
|
73 */ |
|
74 LOCAL_C void TestTruncatedConversionFromUnicodeToGbk(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode) |
|
75 { |
|
76 for (TInt i=aOriginalUnicode.Length(); i>=0; --i) |
|
77 { |
|
78 TBuf8<KBufferLength> generatedGbk; |
|
79 const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGbk, aOriginalUnicode.Left(i)); |
|
80 TEST(returnValue>=0); |
|
81 TBuf8<KBufferLength> generatedsecondPartOfGbk; |
|
82 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfGbk, aOriginalUnicode.Mid(i-returnValue))==0); |
|
83 generatedGbk.Append(generatedsecondPartOfGbk); |
|
84 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
85 TBuf16<KBufferLength> generatedUnicode; |
|
86 TEST(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGbk, state)==0); |
|
87 TEST(generatedUnicode==aOriginalUnicode); |
|
88 } |
|
89 } |
|
90 /** |
|
91 @SYMTestCaseID SYSLIB-CHARCONV-CT-0510 |
|
92 @SYMTestCaseDesc Splitting and converting from Unicode to GBK test |
|
93 @SYMTestPriority Medium |
|
94 @SYMTestActions Tests for conversion after splitting from Unicode to Gbk and back to Unicode |
|
95 Tests for the generated Unicode with original Unicode |
|
96 @SYMTestExpectedResults Test must not fail |
|
97 @SYMREQ REQ0000 |
|
98 */ |
|
99 LOCAL_C void TestSplittingConvertingFromUnicodeToGbk(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfGbk, const TDesC8& aExpectedGbk, const TDesC16& aOriginalUnicode) |
|
100 { |
|
101 TEST(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit); |
|
102 TEST(aMaximumLengthUpperLimit<=KBufferLength); |
|
103 TUint8 gbkBuffer[KBufferLength]; |
|
104 for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i) |
|
105 { |
|
106 TPtr8 generatedFirstPartOfGbk(gbkBuffer, i); |
|
107 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfGbk, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit); |
|
108 TEST(generatedFirstPartOfGbk==aExpectedGbk.Left(aExpectedLengthOfFirstPartOfGbk)); |
|
109 TBuf8<KBufferLength> generatedSecondPartOfGbk; |
|
110 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGbk, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0); |
|
111 TEST(generatedSecondPartOfGbk==aExpectedGbk.Mid(aExpectedLengthOfFirstPartOfGbk)); |
|
112 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
113 TBuf16<KBufferLength> generatedUnicode; |
|
114 TEST(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfGbk, state)==0); |
|
115 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
116 TBuf16<KBufferLength> generatedSecondPartOfUnicode; |
|
117 TEST(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfGbk, state)==0); |
|
118 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
119 generatedUnicode.Append(generatedSecondPartOfUnicode); |
|
120 TEST(generatedUnicode==aOriginalUnicode); |
|
121 } |
|
122 } |
|
123 /** |
|
124 @SYMTestCaseID SYSLIB-CHARCONV-CT-0511 |
|
125 @SYMTestCaseDesc Tests for truncated conversion from GBK to Unicode |
|
126 @SYMTestPriority Medium |
|
127 @SYMTestActions Tests for conversion after truncation from Unicode to Hz and back to Unicode |
|
128 @SYMTestExpectedResults Test must not fail |
|
129 @SYMREQ REQ0000 |
|
130 */ |
|
131 LOCAL_C void TestTruncatedConversionToUnicodeFromGbk(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGbk) |
|
132 { |
|
133 for (TInt i=aOriginalGbk.Length(); i>=2; --i) // 2 is the length of GBK's longest multi-byte characters |
|
134 { |
|
135 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
136 TBuf16<KBufferLength> generatedUnicode; |
|
137 const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGbk.Left(i), state); |
|
138 TEST(returnValue>=0); |
|
139 TBuf16<KBufferLength> generatedsecondPartOfUnicode; |
|
140 TEST(aCharacterSetConverter.ConvertToUnicode(generatedsecondPartOfUnicode, aOriginalGbk.Mid(i-returnValue), state)==0); |
|
141 generatedUnicode.Append(generatedsecondPartOfUnicode); |
|
142 TEST(generatedUnicode==aExpectedUnicode); |
|
143 } |
|
144 } |
|
145 /** |
|
146 @SYMTestCaseID SYSLIB-CHARCONV-CT-0512 |
|
147 @SYMTestCaseDesc Splitting and converting from GBK to Unicode test |
|
148 @SYMTestPriority Medium |
|
149 @SYMTestActions Tests for conversion after splitting from Hz to Unicode and back to Hz |
|
150 @SYMTestExpectedResults Test must not fail |
|
151 @SYMREQ REQ0000 |
|
152 */ |
|
153 LOCAL_C void TestSplittingConvertingToUnicodeFromGbk(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfGbkBytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGbk) |
|
154 { |
|
155 TEST(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit); |
|
156 TEST(aMaximumLengthUpperLimit<=KBufferLength); |
|
157 TUint16 unicodeBuffer[KBufferLength]; |
|
158 for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i) |
|
159 { |
|
160 TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i); |
|
161 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
162 TEST(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalGbk, state)==aExpectedNumberOfGbkBytesNotConvertedAtSplit); |
|
163 TEST(generatedFirstPartOfUnicode==aExpectedUnicode.Left(aExpectedLengthOfFirstPartOfUnicode)); |
|
164 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
165 TBuf16<KBufferLength> generatedSecondPartOfUnicode; |
|
166 TEST(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalGbk.Right(aExpectedNumberOfGbkBytesNotConvertedAtSplit), state)==0); |
|
167 TEST(generatedSecondPartOfUnicode==aExpectedUnicode.Mid(aExpectedLengthOfFirstPartOfUnicode)); |
|
168 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
169 TBuf8<KBufferLength> generatedGbk; |
|
170 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedGbk, generatedFirstPartOfUnicode)==0); |
|
171 TBuf8<KBufferLength> generatedSecondPartOfGbk; |
|
172 TEST(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGbk, generatedSecondPartOfUnicode)==0); |
|
173 generatedGbk.Append(generatedSecondPartOfGbk); |
|
174 TEST(generatedGbk==aOriginalGbk); |
|
175 } |
|
176 } |
|
177 |
|
178 |
|
179 /** |
|
180 Tests retreiving the MIB value from the GBK UID |
|
181 Tests retreiving the GBK UID from the MIB value |
|
182 |
|
183 @SYMTestCaseID SYSLIB-CHARCONV-CT-0513 |
|
184 @SYMTestCaseDesc Tests for conversion from MIB to UID and UID to MIB |
|
185 @SYMTestPriority Medium |
|
186 @SYMTestActions Tests CCnvCharacterSetConverter::ConvertMibEnumOfCharacterSetToIdentifierL(), |
|
187 CCnvCharacterSetConverter::ConvertCharacterSetIdentifierToMibEnumL() functions |
|
188 @SYMTestExpectedResults Test must not fail |
|
189 @SYMREQ REQ0000 |
|
190 */ |
|
191 LOCAL_C void CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession) |
|
192 { |
|
193 // check that the character set value of '113' is converted to the GBK UID (0x10003ecb) |
|
194 TEST(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierGbk); |
|
195 TheTest.Printf(_L("\nMIB->Char Set UID - OK")); |
|
196 |
|
197 // check that the UCS2 GUID (0x10003ecb) is converted to the character set value of '113' |
|
198 TEST(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierGbk,aFileServerSession)==KMibValue); |
|
199 TheTest.Printf(_L("\nChar Set UID->MIB - OK")); |
|
200 } |
|
201 /** |
|
202 @SYMTestCaseID SYSLIB-CHARCONV-CT-0514 |
|
203 @SYMTestCaseDesc Conversion tests for GBK to Unicode |
|
204 @SYMTestPriority Medium |
|
205 @SYMTestActions Tests for conversion from GBK to Unicode and vice versa. |
|
206 @SYMTestExpectedResults Test must not fail |
|
207 @SYMREQ REQ0000 |
|
208 */ |
|
209 LOCAL_C void DoE32MainL() |
|
210 { |
|
211 RFs fileServerSession; |
|
212 CleanupClosePushL(fileServerSession); |
|
213 User::LeaveIfError(fileServerSession.Connect()); |
|
214 CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC(); |
|
215 CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession); |
|
216 TheTest.Printf(_L("Available:\n")); |
|
217 for (TInt i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i) |
|
218 { |
|
219 const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i]; |
|
220 characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession); |
|
221 TPtrC charactersSetName(charactersSet.Name()); |
|
222 if (charactersSet.NameIsFileName()) |
|
223 { |
|
224 charactersSetName.Set(TParsePtrC(charactersSetName).Name()); |
|
225 } |
|
226 TheTest.Printf(_L(" %S\n"), &charactersSetName); |
|
227 } |
|
228 TPtrC8 originalGbk; |
|
229 TBuf16<KBufferLength> originalUnicode; |
|
230 TBuf8<KBufferLength> generatedGbk; |
|
231 TBuf16<KBufferLength> generatedUnicode; |
|
232 TInt state=CCnvCharacterSetConverter::KStateDefault; |
|
233 |
|
234 // test that we can get MIB and Charset values |
|
235 CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession); |
|
236 |
|
237 characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierGbk, *arrayOfCharacterSetsAvailable, fileServerSession); |
|
238 |
|
239 TheTest.Start(_L("Testing characters shared with GB 2312-80 and characters only in GBK")); |
|
240 originalGbk.Set(_L8("A\xfd\x7d\xdd\xb6\xb1\xc9\xe9\x8e\xe8\x9d""E b\xd3\x59\xd2\x40\x95\xc0")); |
|
241 originalUnicode.Format(_L16("A%c%c%c%c%cE b%c%c%c"), 0x9f77, 0x837b, 0x9119, 0x95b9, 0x94e6, 0x89bb, 0x8938, 0x66b2); |
|
242 TestTruncatedConversionFromUnicodeToGbk(*characterSetConverter, originalUnicode); |
|
243 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 0, 0, 12, 0, originalGbk, originalUnicode); |
|
244 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 1, 2, 11, 1, originalGbk, originalUnicode); |
|
245 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 3, 4, 10, 3, originalGbk, originalUnicode); |
|
246 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 5, 6, 9, 5, originalGbk, originalUnicode); |
|
247 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 7, 8, 8, 7, originalGbk, originalUnicode); |
|
248 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 9, 10, 7, 9, originalGbk, originalUnicode); |
|
249 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 11, 11, 6, 11, originalGbk, originalUnicode); |
|
250 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 12, 12, 5, 12, originalGbk, originalUnicode); |
|
251 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 13, 13, 4, 13, originalGbk, originalUnicode); |
|
252 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 14, 15, 3, 14, originalGbk, originalUnicode); |
|
253 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 16, 17, 2, 16, originalGbk, originalUnicode); |
|
254 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 18, 19, 1, 18, originalGbk, originalUnicode); |
|
255 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 20, 40, 0, 20, originalGbk, originalUnicode); |
|
256 TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode, originalGbk); |
|
257 TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode.Mid(1, 2), originalGbk.Mid(1, 4)); |
|
258 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGbk); |
|
259 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 1, 1, 19, 1, originalUnicode, originalGbk); |
|
260 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 2, 2, 17, 2, originalUnicode, originalGbk); |
|
261 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 3, 3, 15, 3, originalUnicode, originalGbk); |
|
262 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 4, 4, 13, 4, originalUnicode, originalGbk); |
|
263 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 5, 5, 11, 5, originalUnicode, originalGbk); |
|
264 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 6, 6, 9, 6, originalUnicode, originalGbk); |
|
265 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 7, 7, 8, 7, originalUnicode, originalGbk); |
|
266 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 8, 8, 7, 8, originalUnicode, originalGbk); |
|
267 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGbk); |
|
268 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 10, 10, 4, 10, originalUnicode, originalGbk); |
|
269 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 11, 11, 2, 11, originalUnicode, originalGbk); |
|
270 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 12, 30, 0, 12, originalUnicode, originalGbk); |
|
271 |
|
272 TheTest.Next(_L("Testing GBK characters where the first byte has the high-bit set and the second byte doesn't")); |
|
273 originalGbk.Set(_L8("\x20\x5d\xa0\x5d\xa0\xdd")); |
|
274 originalUnicode.Format(_L16(" ]%c%c"), 0x71f7, 0x72a6); |
|
275 TestTruncatedConversionFromUnicodeToGbk(*characterSetConverter, originalUnicode); |
|
276 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 0, 0, 4, 0, originalGbk, originalUnicode); |
|
277 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 1, 1, 3, 1, originalGbk, originalUnicode); |
|
278 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 2, 3, 2, 2, originalGbk, originalUnicode); |
|
279 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 4, 5, 1, 4, originalGbk, originalUnicode); |
|
280 TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 6, 20, 0, 6, originalGbk, originalUnicode); |
|
281 TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode, originalGbk); |
|
282 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 0, 0, 6, 0, originalUnicode, originalGbk); |
|
283 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 1, 1, 5, 1, originalUnicode, originalGbk); |
|
284 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 2, 2, 4, 2, originalUnicode, originalGbk); |
|
285 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 3, 3, 2, 3, originalUnicode, originalGbk); |
|
286 TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 4, 20, 0, 4, originalUnicode, originalGbk); |
|
287 |
|
288 TheTest.Next(_L("Testing the many-to-many mapping in GBK")); |
|
289 originalGbk.Set(_L8("\xa8\x44\xa1\xaa")); |
|
290 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==0); |
|
291 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
292 TEST(generatedUnicode.Length()==2); |
|
293 TEST(generatedUnicode[0]==0x2015); |
|
294 TEST(generatedUnicode[1]==0x2015); |
|
295 originalUnicode.SetLength(2); |
|
296 originalUnicode[0]=0x2014; |
|
297 originalUnicode[1]=0x2015; |
|
298 TEST(characterSetConverter->ConvertFromUnicode(generatedGbk, originalUnicode)==0); |
|
299 TEST(generatedGbk==_L8("\xa1\xaa\xa1\xaa")); |
|
300 |
|
301 TheTest.Next(_L("Testing truncated GBK sequences")); |
|
302 originalGbk.Set(_L8("qwe\xb5")); |
|
303 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==1); |
|
304 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
305 TEST(generatedUnicode==_L16("qwe")); |
|
306 originalGbk.Set(_L8("qwe\x80")); |
|
307 TEST(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==1); |
|
308 TEST(state==CCnvCharacterSetConverter::KStateDefault); |
|
309 TEST(generatedUnicode==_L16("qwe")); |
|
310 CleanupStack::PopAndDestroy(3); // arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession |
|
311 } |
|
312 |
|
313 GLDEF_C TInt E32Main() |
|
314 { |
|
315 __UHEAP_MARK; |
|
316 |
|
317 TheTest.Title(); |
|
318 |
|
319 CTrapCleanup* trapCleanup=CTrapCleanup::New(); |
|
320 TEST(trapCleanup != NULL); |
|
321 |
|
322 TRAPD(error, DoE32MainL()); |
|
323 TEST2(error, KErrNone); |
|
324 |
|
325 delete trapCleanup; |
|
326 |
|
327 TheTest.End(); |
|
328 TheTest.Close(); |
|
329 |
|
330 __UHEAP_MARKEND; |
|
331 return KErrNone; |
|
332 } |
|
333 |