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