]>
Commit | Line | Data |
---|---|---|
b75a7d8f A |
1 | /* |
2 | ******************************************************************************* | |
3 | * | |
51004dcb | 4 | * Copyright (C) 2003-2012, International Business Machines |
b75a7d8f A |
5 | * Corporation and others. All Rights Reserved. |
6 | * | |
7 | ******************************************************************************* | |
8 | * file name: testidna.cpp | |
9 | * encoding: US-ASCII | |
10 | * tab size: 8 (not used) | |
11 | * indentation:4 | |
12 | * | |
13 | * created on: 2003feb1 | |
14 | * created by: Ram Viswanadha | |
15 | */ | |
16 | ||
17 | #include "unicode/utypes.h" | |
18 | ||
19 | #if !UCONFIG_NO_IDNA && !UCONFIG_NO_TRANSLITERATION | |
20 | ||
b75a7d8f A |
21 | #include <time.h> |
22 | #include <limits.h> | |
374ca955 A |
23 | #include <stdlib.h> |
24 | #include <string.h> | |
729e4ab9 | 25 | #include "unicode/localpointer.h" |
b75a7d8f | 26 | #include "unicode/ustring.h" |
374ca955 | 27 | #include "unicode/usprep.h" |
b75a7d8f | 28 | #include "unicode/uniset.h" |
b75a7d8f A |
29 | #include "testidna.h" |
30 | #include "idnaref.h" | |
31 | #include "nptrans.h" | |
374ca955 | 32 | #include "unicode/putil.h" |
73c04bcf | 33 | #include "idnaconf.h" |
b75a7d8f | 34 | |
46f4442e | 35 | static const UChar unicodeIn[][41] ={ |
b75a7d8f A |
36 | { |
37 | 0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644, | |
38 | 0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F, 0x0000 | |
39 | }, | |
40 | { | |
41 | 0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587, | |
42 | 0x0000 | |
43 | }, | |
44 | { | |
45 | 0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074, | |
46 | 0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D, | |
47 | 0x0065, 0x0073, 0x006B, 0x0079, 0x0000 | |
48 | }, | |
49 | { | |
50 | 0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8, | |
51 | 0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2, | |
52 | 0x05D1, 0x05E8, 0x05D9, 0x05EA, 0x0000 | |
53 | }, | |
54 | { | |
55 | 0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D, | |
56 | 0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939, | |
57 | 0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947, | |
58 | 0x0939, 0x0948, 0x0902, 0x0000 | |
59 | }, | |
60 | { | |
61 | 0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092, | |
62 | 0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B, | |
63 | 0x0000 | |
64 | }, | |
65 | /* | |
66 | { | |
67 | 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
68 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
69 | 0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 0x0000 | |
70 | }, | |
71 | */ | |
72 | { | |
73 | 0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E, | |
74 | 0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440, | |
75 | 0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A, | |
76 | 0x0438, 0x0000 | |
77 | }, | |
78 | { | |
79 | 0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070, | |
80 | 0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070, | |
81 | 0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061, | |
82 | 0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070, | |
83 | 0x0061, 0x00F1, 0x006F, 0x006C, 0x0000 | |
84 | }, | |
85 | { | |
86 | 0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587, | |
87 | 0x0000 | |
88 | }, | |
89 | { | |
90 | 0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B, | |
91 | 0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068, | |
92 | 0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067, | |
93 | 0x0056, 0x0069, 0x1EC7, 0x0074, 0x0000 | |
94 | }, | |
95 | { | |
96 | 0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F, 0x0000 | |
97 | }, | |
98 | { | |
99 | 0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074, | |
100 | 0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D, | |
101 | 0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053, 0x0000 | |
102 | }, | |
103 | { | |
104 | 0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F, | |
105 | 0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D, | |
106 | 0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240, 0x0000 | |
107 | }, | |
108 | { | |
109 | 0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032, 0x0000 | |
110 | }, | |
111 | { | |
112 | 0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059, | |
113 | 0x308B, 0x0035, 0x79D2, 0x524D, 0x0000 | |
114 | }, | |
115 | { | |
116 | 0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0, | |
117 | 0x0000 | |
118 | }, | |
119 | { | |
120 | 0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067, 0x0000 | |
121 | }, | |
122 | // test non-BMP code points | |
123 | { | |
124 | 0xD800, 0xDF00, 0xD800, 0xDF01, 0xD800, 0xDF02, 0xD800, 0xDF03, 0xD800, 0xDF05, | |
125 | 0xD800, 0xDF06, 0xD800, 0xDF07, 0xD800, 0xDF09, 0xD800, 0xDF0A, 0xD800, 0xDF0B, | |
126 | 0x0000 | |
127 | }, | |
128 | { | |
129 | 0xD800, 0xDF0D, 0xD800, 0xDF0C, 0xD800, 0xDF1E, 0xD800, 0xDF0F, 0xD800, 0xDF16, | |
130 | 0xD800, 0xDF15, 0xD800, 0xDF14, 0xD800, 0xDF12, 0xD800, 0xDF10, 0xD800, 0xDF20, | |
131 | 0xD800, 0xDF21, | |
132 | 0x0000 | |
133 | }, | |
134 | // Greek | |
135 | { | |
136 | 0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac | |
137 | }, | |
138 | // Maltese | |
139 | { | |
140 | 0x0062, 0x006f, 0x006e, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127, | |
141 | 0x0127, 0x0061 | |
142 | }, | |
143 | // Russian | |
144 | { | |
145 | 0x043f, 0x043e, 0x0447, 0x0435, 0x043c, 0x0443, 0x0436, 0x0435, | |
146 | 0x043e, 0x043d, 0x0438, 0x043d, 0x0435, 0x0433, 0x043e, 0x0432, | |
147 | 0x043e, 0x0440, 0x044f, 0x0442, 0x043f, 0x043e, 0x0440, 0x0443, | |
148 | 0x0441, 0x0441, 0x043a, 0x0438 | |
374ca955 | 149 | }, |
73c04bcf A |
150 | { |
151 | 0xFB00, 0xFB01 | |
152 | } | |
374ca955 | 153 | |
b75a7d8f A |
154 | }; |
155 | ||
156 | static const char *asciiIn[] = { | |
157 | "xn--egbpdaj6bu4bxfgehfvwxn", | |
158 | "xn--ihqwcrb4cv8a8dqg056pqjye", | |
159 | "xn--Proprostnemluvesky-uyb24dma41a", | |
160 | "xn--4dbcagdahymbxekheh6e0a7fei0b", | |
161 | "xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd", | |
162 | "xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa", | |
163 | /* "xn--989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",*/ | |
164 | "xn--b1abfaaepdrnnbgefbaDotcwatmq2g4l", | |
165 | "xn--PorqunopuedensimplementehablarenEspaol-fmd56a", | |
166 | "xn--ihqwctvzc91f659drss3x8bo0yb", | |
167 | "xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g", | |
168 | "xn--3B-ww4c5e180e575a65lsy2b", | |
169 | "xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n", | |
170 | "xn--Hello-Another-Way--fc4qua05auwb3674vfr0b", | |
171 | "xn--2-u9tlzr9756bt3uc0v", | |
172 | "xn--MajiKoi5-783gue6qz075azm5e", | |
173 | "xn--de-jg4avhby1noc0d", | |
174 | "xn--d9juau41awczczp", | |
175 | "XN--097CCDEKGHQJK", | |
176 | "XN--db8CBHEJLGH4E0AL", | |
177 | "xn--hxargifdar", // Greek | |
178 | "xn--bonusaa-5bb1da", // Maltese | |
179 | "xn--b1abfaaepdrnnbgefbadotcwatmq2g4l", // Russian (Cyrillic) | |
73c04bcf | 180 | "fffi" |
b75a7d8f A |
181 | }; |
182 | ||
183 | static const char *domainNames[] = { | |
184 | "slip129-37-118-146.nc.us.ibm.net", | |
185 | "saratoga.pe.utexas.edu", | |
186 | "dial-120-45.ots.utexas.edu", | |
187 | "woo-085.dorms.waller.net", | |
188 | "hd30-049.hil.compuserve.com", | |
189 | "pem203-31.pe.ttu.edu", | |
190 | "56K-227.MaxTNT3.pdq.net", | |
191 | "dial-36-2.ots.utexas.edu", | |
192 | "slip129-37-23-152.ga.us.ibm.net", | |
193 | "ts45ip119.cadvision.com", | |
194 | "sdn-ts-004txaustP05.dialsprint.net", | |
195 | "bar-tnt1s66.erols.com", | |
196 | "101.st-louis-15.mo.dial-access.att.net", | |
197 | "h92-245.Arco.COM", | |
198 | "dial-13-2.ots.utexas.edu", | |
199 | "net-redynet29.datamarkets.com.ar", | |
200 | "ccs-shiva28.reacciun.net.ve", | |
201 | "7.houston-11.tx.dial-access.att.net", | |
202 | "ingw129-37-120-26.mo.us.ibm.net", | |
203 | "dialup6.austintx.com", | |
204 | "dns2.tpao.gov.tr", | |
205 | "slip129-37-119-194.nc.us.ibm.net", | |
206 | "cs7.dillons.co.uk.203.119.193.in-addr.arpa", | |
207 | "swprd1.innovplace.saskatoon.sk.ca", | |
208 | "bikini.bologna.maraut.it", | |
209 | "node91.subnet159-198-79.baxter.com", | |
210 | "cust19.max5.new-york.ny.ms.uu.net", | |
211 | "balexander.slip.andrew.cmu.edu", | |
212 | "pool029.max2.denver.co.dynip.alter.net", | |
213 | "cust49.max9.new-york.ny.ms.uu.net", | |
214 | "s61.abq-dialin2.hollyberry.com", | |
374ca955 | 215 | "\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com", //':'(0x003a) produces U_IDNA_STD3_ASCII_RULES_ERROR |
b75a7d8f | 216 | "www.xn--vea.com", |
374ca955 | 217 | // "www.\\u00E0\\u00B3\\u00AF.com",//' ' (0x0020) produces U_IDNA_STD3_ASCII_RULES_ERROR |
b75a7d8f A |
218 | "www.\\u00C2\\u00A4.com", |
219 | "www.\\u00C2\\u00A3.com", | |
374ca955 A |
220 | // "\\u0025", //'%' (0x0025) produces U_IDNA_STD3_ASCII_RULES_ERROR |
221 | // "\\u005C\\u005C", //'\' (0x005C) produces U_IDNA_STD3_ASCII_RULES_ERROR | |
222 | //"@", | |
223 | //"\\u002F", | |
224 | //"www.\\u0021.com", | |
225 | //"www.\\u0024.com", | |
226 | //"\\u003f", | |
227 | // These yeild U_IDNA_PROHIBITED_ERROR | |
b75a7d8f A |
228 | //"\\u00CF\\u0082.com", |
229 | //"\\u00CE\\u00B2\\u00C3\\u009Fss.com", | |
230 | //"\\u00E2\\u0098\\u00BA.com", | |
231 | "\\u00C3\\u00BC.com", | |
232 | ||
233 | }; | |
234 | ||
235 | typedef struct ErrorCases ErrorCases; | |
236 | ||
46f4442e | 237 | static const struct ErrorCases{ |
b75a7d8f A |
238 | |
239 | UChar unicode[100]; | |
240 | const char *ascii; | |
241 | UErrorCode expected; | |
242 | UBool useSTD3ASCIIRules; | |
243 | UBool testToUnicode; | |
244 | UBool testLabel; | |
245 | } errorCases[] = { | |
246 | { | |
247 | ||
248 | { | |
249 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
250 | 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
374ca955 | 251 | 0x070F,/*prohibited*/ |
b75a7d8f A |
252 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, |
253 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
254 | 0x0000 | |
255 | }, | |
374ca955 A |
256 | "www.XN--8mb5595fsoa28orucya378bqre2tcwop06c5qbw82a1rffmae0361dea96b.com", |
257 | U_IDNA_PROHIBITED_ERROR, | |
46f4442e | 258 | FALSE, FALSE, TRUE |
b75a7d8f A |
259 | }, |
260 | ||
261 | { | |
262 | { | |
263 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
264 | 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
265 | 0x0221, 0x0234/*Unassigned code points*/, | |
266 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
267 | 0x0000 | |
268 | }, | |
269 | "www.XN--6lA2Bz548Fj1GuA391Bf1Gb1N59Ab29A7iA.com", | |
270 | ||
374ca955 | 271 | U_IDNA_UNASSIGNED_ERROR, |
46f4442e | 272 | FALSE, FALSE, TRUE |
b75a7d8f A |
273 | }, |
274 | { | |
275 | { | |
276 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
277 | 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
278 | 0x0644, 0x064A, 0x0647,/*Arabic code points. Cannot mix RTL with LTR*/ | |
279 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
280 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
281 | 0x0000 | |
282 | }, | |
283 | "www.xn--ghBGI4851OiyA33VqrD6Az86C4qF83CtRv93D5xBk15AzfG0nAgA0578DeA71C.com", | |
284 | U_IDNA_CHECK_BIDI_ERROR, | |
46f4442e | 285 | FALSE, FALSE, TRUE |
b75a7d8f A |
286 | }, |
287 | { | |
288 | { | |
289 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
290 | /* labels cannot begin with an HYPHEN */ | |
291 | 0x002D, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
292 | 0x002E, | |
293 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
294 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
295 | 0x0000 | |
296 | ||
297 | }, | |
298 | "www.xn----b95Ew8SqA315Ao5FbuMlnNmhA.com", | |
299 | U_IDNA_STD3_ASCII_RULES_ERROR, | |
46f4442e | 300 | TRUE, FALSE, FALSE |
b75a7d8f A |
301 | }, |
302 | { | |
303 | { | |
304 | /* correct ACE-prefix followed by unicode */ | |
305 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
306 | 0x0078, 0x006e, 0x002d,0x002d, /* ACE Prefix */ | |
307 | 0x002D, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
308 | 0x002D, | |
309 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
310 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
311 | 0x0000 | |
312 | ||
313 | }, | |
314 | /* wrong ACE-prefix followed by valid ACE-encoded ASCII */ | |
315 | "www.XY-----b91I0V65S96C2A355Cw1E5yCeQr19CsnP1mFfmAE0361DeA96B.com", | |
316 | U_IDNA_ACE_PREFIX_ERROR, | |
317 | FALSE, FALSE, FALSE | |
318 | }, | |
319 | /* cannot verify U_IDNA_VERIFICATION_ERROR */ | |
320 | ||
321 | { | |
322 | { | |
323 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
324 | 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
325 | 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
326 | 0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, | |
327 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
328 | 0x0000 | |
329 | }, | |
330 | "www.xn--989AoMsVi5E83Db1D2A355Cv1E0vAk1DwRv93D5xBh15A0Dt30A5JpSD879Ccm6FeA98C.com", | |
331 | U_IDNA_LABEL_TOO_LONG_ERROR, | |
46f4442e | 332 | FALSE, FALSE, TRUE |
b75a7d8f A |
333 | }, |
334 | ||
335 | { | |
336 | { | |
337 | 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ | |
338 | 0x0030, 0x0644, 0x064A, 0x0647, 0x0031, /* Arabic code points squashed between EN codepoints */ | |
339 | 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ | |
340 | 0x0000 | |
341 | }, | |
342 | "www.xn--01-tvdmo.com", | |
343 | U_IDNA_CHECK_BIDI_ERROR, | |
46f4442e | 344 | FALSE, FALSE, TRUE |
b75a7d8f A |
345 | }, |
346 | ||
347 | { | |
348 | { | |
349 | 0x0077, 0x0077, 0x0077, 0x002e, // www. | |
350 | 0x206C, 0x0644, 0x064A, 0x0647, 0x206D, // Arabic code points squashed between BN codepoints | |
351 | 0x002e, 0x0063, 0x006f, 0x006d, // com. | |
352 | 0x0000 | |
353 | }, | |
354 | "www.XN--ghbgi278xia.com", | |
374ca955 | 355 | U_IDNA_PROHIBITED_ERROR, |
46f4442e | 356 | FALSE, FALSE, TRUE |
b75a7d8f A |
357 | }, |
358 | { | |
359 | { | |
360 | 0x0077, 0x0077, 0x0077, 0x002e, // www. | |
361 | 0x002D, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, // HYPHEN at the start of label | |
362 | 0x002e, 0x0063, 0x006f, 0x006d, // com. | |
363 | 0x0000 | |
364 | }, | |
365 | "www.-abcde.com", | |
366 | U_IDNA_STD3_ASCII_RULES_ERROR, | |
46f4442e | 367 | TRUE, FALSE, FALSE |
b75a7d8f A |
368 | }, |
369 | { | |
370 | { | |
371 | 0x0077, 0x0077, 0x0077, 0x002e, // www. | |
372 | 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,0x002D, // HYPHEN at the end of the label | |
373 | 0x002e, 0x0063, 0x006f, 0x006d, // com. | |
374 | 0x0000 | |
375 | }, | |
376 | "www.abcde-.com", | |
377 | U_IDNA_STD3_ASCII_RULES_ERROR, | |
46f4442e | 378 | TRUE, FALSE, FALSE |
b75a7d8f A |
379 | }, |
380 | { | |
381 | { | |
382 | 0x0077, 0x0077, 0x0077, 0x002e, // www. | |
383 | 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,0x0040, // Containing non LDH code point | |
384 | 0x002e, 0x0063, 0x006f, 0x006d, // com. | |
385 | 0x0000 | |
386 | }, | |
387 | "www.abcde@.com", | |
388 | U_IDNA_STD3_ASCII_RULES_ERROR, | |
46f4442e | 389 | TRUE, FALSE, FALSE |
b75a7d8f | 390 | }, |
73c04bcf A |
391 | { |
392 | { | |
393 | 0x0077, 0x0077, 0x0077, 0x002e, // www. | |
394 | // zero length label | |
395 | 0x002e, 0x0063, 0x006f, 0x006d, // com. | |
396 | 0x0000 | |
397 | }, | |
398 | "www..com", | |
399 | U_IDNA_ZERO_LENGTH_LABEL_ERROR, | |
46f4442e | 400 | TRUE, FALSE, FALSE |
73c04bcf | 401 | }, |
b75a7d8f A |
402 | { |
403 | {0}, | |
404 | NULL, | |
405 | U_ILLEGAL_ARGUMENT_ERROR, | |
406 | TRUE, TRUE, FALSE | |
407 | } | |
408 | }; | |
409 | ||
410 | ||
b75a7d8f A |
411 | |
412 | ||
413 | #define MAX_DEST_SIZE 300 | |
414 | ||
374ca955 A |
415 | void TestIDNA::debug(const UChar* src, int32_t srcLength, int32_t options){ |
416 | UParseError parseError; | |
417 | UErrorCode transStatus = U_ZERO_ERROR; | |
418 | UErrorCode prepStatus = U_ZERO_ERROR; | |
419 | NamePrepTransform* trans = NamePrepTransform::createInstance(parseError,transStatus); | |
420 | int32_t prepOptions = (((options & UIDNA_ALLOW_UNASSIGNED) != 0) ? USPREP_ALLOW_UNASSIGNED: 0); | |
729e4ab9 | 421 | LocalUStringPrepProfilePointer prep(usprep_openByType(USPREP_RFC3491_NAMEPREP,&prepStatus)); |
374ca955 A |
422 | UChar *transOut=NULL, *prepOut=NULL; |
423 | int32_t transOutLength=0, prepOutLength=0; | |
424 | ||
425 | ||
426 | transOutLength = trans->process(src,srcLength,transOut, 0, prepOptions>0, &parseError, transStatus); | |
427 | if( transStatus == U_BUFFER_OVERFLOW_ERROR){ | |
428 | transStatus = U_ZERO_ERROR; | |
429 | transOut = (UChar*) malloc(U_SIZEOF_UCHAR * transOutLength); | |
430 | transOutLength = trans->process(src,srcLength,transOut, transOutLength, prepOptions>0, &parseError, transStatus); | |
431 | } | |
432 | ||
729e4ab9 | 433 | prepOutLength = usprep_prepare(prep.getAlias(), src, srcLength, prepOut, 0, prepOptions, &parseError, &prepStatus); |
b75a7d8f | 434 | |
374ca955 A |
435 | if( prepStatus == U_BUFFER_OVERFLOW_ERROR){ |
436 | prepStatus = U_ZERO_ERROR; | |
437 | prepOut = (UChar*) malloc(U_SIZEOF_UCHAR * prepOutLength); | |
729e4ab9 | 438 | prepOutLength = usprep_prepare(prep.getAlias(), src, srcLength, prepOut, prepOutLength, prepOptions, &parseError, &prepStatus); |
374ca955 A |
439 | } |
440 | ||
441 | if(UnicodeString(transOut,transOutLength)!= UnicodeString(prepOut, prepOutLength)){ | |
442 | errln("Failed. Expected: " + prettify(UnicodeString(transOut, transOutLength)) | |
443 | + " Got: " + prettify(UnicodeString(prepOut,prepOutLength))); | |
444 | } | |
445 | free(transOut); | |
446 | free(prepOut); | |
447 | delete trans; | |
374ca955 | 448 | } |
b75a7d8f A |
449 | |
450 | void TestIDNA::testAPI(const UChar* src, const UChar* expected, const char* testName, | |
451 | UBool useSTD3ASCIIRules,UErrorCode expectedStatus, | |
374ca955 | 452 | UBool doCompare, UBool testUnassigned, TestFunc func, UBool testSTD3ASCIIRules){ |
b75a7d8f A |
453 | |
454 | UErrorCode status = U_ZERO_ERROR; | |
455 | UChar destStack[MAX_DEST_SIZE]; | |
456 | int32_t destLen = 0; | |
457 | UChar* dest = NULL; | |
458 | int32_t expectedLen = (expected != NULL) ? u_strlen(expected) : 0; | |
459 | int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT; | |
460 | UParseError parseError; | |
461 | int32_t tSrcLen = 0; | |
462 | UChar* tSrc = NULL; | |
463 | ||
464 | if(src != NULL){ | |
465 | tSrcLen = u_strlen(src); | |
374ca955 A |
466 | tSrc =(UChar*) malloc( U_SIZEOF_UCHAR * tSrcLen ); |
467 | memcpy(tSrc,src,tSrcLen * U_SIZEOF_UCHAR); | |
b75a7d8f A |
468 | } |
469 | ||
470 | // test null-terminated source and return value of number of UChars required | |
374ca955 A |
471 | destLen = func(src,-1,NULL,0,options, &parseError , &status); |
472 | if(status == U_BUFFER_OVERFLOW_ERROR){ | |
473 | status = U_ZERO_ERROR; // reset error code | |
474 | if(destLen+1 < MAX_DEST_SIZE){ | |
475 | dest = destStack; | |
476 | destLen = func(src,-1,dest,destLen+1,options, &parseError, &status); | |
477 | // TODO : compare output with expected | |
478 | if(U_SUCCESS(status) && expectedStatus != U_IDNA_STD3_ASCII_RULES_ERROR&& (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ | |
479 | errln("Did not get the expected result for "+UnicodeString(testName) +" null terminated source. Expected : " | |
480 | + prettify(UnicodeString(expected,expectedLen)) | |
481 | + " Got: " + prettify(UnicodeString(dest,destLen)) | |
482 | ); | |
483 | } | |
484 | }else{ | |
485 | errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); | |
486 | } | |
487 | } | |
488 | ||
489 | if(status != expectedStatus){ | |
729e4ab9 | 490 | errcheckln(status, "Did not get the expected error for "+ |
374ca955 | 491 | UnicodeString(testName)+ |
73c04bcf | 492 | " null terminated source. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
493 | + " Got: "+ UnicodeString(u_errorName(status)) |
494 | + " Source: " + prettify(UnicodeString(src)) | |
495 | ); | |
496 | free(tSrc); | |
497 | return; | |
498 | } | |
499 | if(testUnassigned ){ | |
500 | status = U_ZERO_ERROR; | |
501 | destLen = func(src,-1,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
b75a7d8f A |
502 | if(status == U_BUFFER_OVERFLOW_ERROR){ |
503 | status = U_ZERO_ERROR; // reset error code | |
504 | if(destLen+1 < MAX_DEST_SIZE){ | |
505 | dest = destStack; | |
374ca955 | 506 | destLen = func(src,-1,dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); |
b75a7d8f | 507 | // TODO : compare output with expected |
374ca955 A |
508 | if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ |
509 | //errln("Did not get the expected result for %s null terminated source with both options set.\n",testName); | |
510 | errln("Did not get the expected result for "+UnicodeString(testName) + | |
511 | " null terminated source "+ prettify(src) + | |
512 | " with both options set. Expected: "+ prettify(UnicodeString(expected,expectedLen))+ | |
513 | "Got: " + prettify(UnicodeString(dest,destLen))); | |
514 | ||
515 | debug(src,-1,options | UIDNA_ALLOW_UNASSIGNED); | |
516 | ||
b75a7d8f A |
517 | } |
518 | }else{ | |
519 | errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); | |
520 | } | |
521 | } | |
374ca955 A |
522 | //testing query string |
523 | if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ | |
73c04bcf | 524 | errln( "Did not get the expected error for "+ |
374ca955 | 525 | UnicodeString(testName)+ |
73c04bcf | 526 | " null terminated source with options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
527 | + " Got: "+ UnicodeString(u_errorName(status)) |
528 | + " Source: " + prettify(UnicodeString(src)) | |
529 | ); | |
530 | } | |
531 | } | |
b75a7d8f | 532 | |
374ca955 A |
533 | status = U_ZERO_ERROR; |
534 | ||
535 | // test source with lengthand return value of number of UChars required | |
536 | destLen = func(tSrc, tSrcLen, NULL,0,options, &parseError, &status); | |
537 | if(status == U_BUFFER_OVERFLOW_ERROR){ | |
538 | status = U_ZERO_ERROR; // reset error code | |
539 | if(destLen+1 < MAX_DEST_SIZE){ | |
540 | dest = destStack; | |
541 | destLen = func(src,u_strlen(src),dest,destLen+1,options, &parseError, &status); | |
542 | // TODO : compare output with expected | |
543 | if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ | |
544 | errln("Did not get the expected result for %s with source length.\n",testName); | |
b75a7d8f | 545 | } |
374ca955 A |
546 | }else{ |
547 | errln( "%s with source length failed. Requires destCapacity > 300\n",testName); | |
b75a7d8f | 548 | } |
374ca955 | 549 | } |
b75a7d8f | 550 | |
374ca955 | 551 | if(status != expectedStatus){ |
73c04bcf | 552 | errln( "Did not get the expected error for "+ |
374ca955 | 553 | UnicodeString(testName)+ |
73c04bcf | 554 | " with source length. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
555 | + " Got: "+ UnicodeString(u_errorName(status)) |
556 | + " Source: " + prettify(UnicodeString(src)) | |
557 | ); | |
558 | } | |
559 | if(testUnassigned){ | |
b75a7d8f A |
560 | status = U_ZERO_ERROR; |
561 | ||
374ca955 A |
562 | destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); |
563 | ||
b75a7d8f A |
564 | if(status == U_BUFFER_OVERFLOW_ERROR){ |
565 | status = U_ZERO_ERROR; // reset error code | |
566 | if(destLen+1 < MAX_DEST_SIZE){ | |
567 | dest = destStack; | |
374ca955 | 568 | destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); |
b75a7d8f A |
569 | // TODO : compare output with expected |
570 | if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ | |
374ca955 | 571 | errln("Did not get the expected result for %s with source length and both options set.\n",testName); |
b75a7d8f A |
572 | } |
573 | }else{ | |
574 | errln( "%s with source length failed. Requires destCapacity > 300\n",testName); | |
575 | } | |
576 | } | |
374ca955 A |
577 | //testing query string |
578 | if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ | |
73c04bcf | 579 | errln( "Did not get the expected error for "+ |
374ca955 | 580 | UnicodeString(testName)+ |
73c04bcf | 581 | " with source length and options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
582 | + " Got: "+ UnicodeString(u_errorName(status)) |
583 | + " Source: " + prettify(UnicodeString(src)) | |
584 | ); | |
b75a7d8f | 585 | } |
374ca955 | 586 | } |
b75a7d8f | 587 | |
374ca955 A |
588 | status = U_ZERO_ERROR; |
589 | if(testSTD3ASCIIRules==TRUE){ | |
590 | destLen = func(src,-1,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status); | |
b75a7d8f A |
591 | if(status == U_BUFFER_OVERFLOW_ERROR){ |
592 | status = U_ZERO_ERROR; // reset error code | |
593 | if(destLen+1 < MAX_DEST_SIZE){ | |
594 | dest = destStack; | |
595 | destLen = func(src,-1,dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status); | |
596 | // TODO : compare output with expected | |
597 | if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ | |
598 | //errln("Did not get the expected result for %s null terminated source with both options set.\n",testName); | |
599 | errln("Did not get the expected result for "+UnicodeString(testName) +" null terminated source with both options set. Expected: "+ prettify(UnicodeString(expected,expectedLen))); | |
374ca955 | 600 | |
b75a7d8f A |
601 | } |
602 | }else{ | |
603 | errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); | |
604 | } | |
605 | } | |
606 | //testing query string | |
607 | if(status != expectedStatus){ | |
73c04bcf | 608 | errln( "Did not get the expected error for "+ |
374ca955 | 609 | UnicodeString(testName)+ |
73c04bcf | 610 | " null terminated source with options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
611 | + " Got: "+ UnicodeString(u_errorName(status)) |
612 | + " Source: " + prettify(UnicodeString(src)) | |
613 | ); | |
b75a7d8f A |
614 | } |
615 | ||
616 | status = U_ZERO_ERROR; | |
617 | ||
374ca955 | 618 | destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status); |
b75a7d8f A |
619 | |
620 | if(status == U_BUFFER_OVERFLOW_ERROR){ | |
621 | status = U_ZERO_ERROR; // reset error code | |
622 | if(destLen+1 < MAX_DEST_SIZE){ | |
623 | dest = destStack; | |
624 | destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status); | |
625 | // TODO : compare output with expected | |
626 | if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ | |
627 | errln("Did not get the expected result for %s with source length and both options set.\n",testName); | |
628 | } | |
629 | }else{ | |
630 | errln( "%s with source length failed. Requires destCapacity > 300\n",testName); | |
631 | } | |
632 | } | |
633 | //testing query string | |
374ca955 | 634 | if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ |
73c04bcf | 635 | errln( "Did not get the expected error for "+ |
374ca955 | 636 | UnicodeString(testName)+ |
73c04bcf | 637 | " with source length and options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) |
374ca955 A |
638 | + " Got: "+ UnicodeString(u_errorName(status)) |
639 | + " Source: " + prettify(UnicodeString(src)) | |
640 | ); | |
b75a7d8f A |
641 | } |
642 | } | |
374ca955 | 643 | free(tSrc); |
b75a7d8f A |
644 | } |
645 | ||
646 | void TestIDNA::testCompare(const UChar* s1, int32_t s1Len, | |
647 | const UChar* s2, int32_t s2Len, | |
648 | const char* testName, CompareFunc func, | |
649 | UBool isEqual){ | |
650 | ||
651 | UErrorCode status = U_ZERO_ERROR; | |
652 | int32_t retVal = func(s1,-1,s2,-1,UIDNA_DEFAULT,&status); | |
653 | ||
654 | if(isEqual==TRUE && retVal !=0){ | |
655 | errln("Did not get the expected result for %s with null termniated strings.\n",testName); | |
656 | } | |
657 | if(U_FAILURE(status)){ | |
729e4ab9 | 658 | errcheckln(status, "%s null terminated source failed. Error: %s", testName,u_errorName(status)); |
b75a7d8f A |
659 | } |
660 | ||
661 | status = U_ZERO_ERROR; | |
662 | retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status); | |
663 | ||
664 | if(isEqual==TRUE && retVal !=0){ | |
665 | errln("Did not get the expected result for %s with null termniated strings with options set.\n", testName); | |
666 | } | |
667 | if(U_FAILURE(status)){ | |
729e4ab9 | 668 | errcheckln(status, "%s null terminated source and options set failed. Error: %s",testName, u_errorName(status)); |
b75a7d8f A |
669 | } |
670 | ||
671 | status = U_ZERO_ERROR; | |
672 | retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status); | |
673 | ||
674 | if(isEqual==TRUE && retVal !=0){ | |
675 | errln("Did not get the expected result for %s with string length.\n",testName); | |
676 | } | |
677 | if(U_FAILURE(status)){ | |
729e4ab9 | 678 | errcheckln(status, "%s with string length. Error: %s",testName, u_errorName(status)); |
b75a7d8f A |
679 | } |
680 | ||
681 | status = U_ZERO_ERROR; | |
682 | retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status); | |
683 | ||
684 | if(isEqual==TRUE && retVal !=0){ | |
685 | errln("Did not get the expected result for %s with string length and options set.\n",testName); | |
686 | } | |
687 | if(U_FAILURE(status)){ | |
729e4ab9 | 688 | errcheckln(status, "%s with string length and options set. Error: %s", u_errorName(status), testName); |
b75a7d8f A |
689 | } |
690 | } | |
691 | ||
692 | void TestIDNA::testToASCII(const char* testName, TestFunc func){ | |
693 | ||
694 | int32_t i; | |
695 | UChar buf[MAX_DEST_SIZE]; | |
696 | ||
697 | for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
374ca955 | 698 | u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); |
b75a7d8f A |
699 | testAPI(unicodeIn[i], buf,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); |
700 | ||
701 | } | |
702 | } | |
703 | ||
704 | void TestIDNA::testToUnicode(const char* testName, TestFunc func){ | |
705 | ||
706 | int32_t i; | |
707 | UChar buf[MAX_DEST_SIZE]; | |
708 | ||
709 | for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){ | |
374ca955 | 710 | u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); |
b75a7d8f A |
711 | testAPI(buf,unicodeIn[i],testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); |
712 | } | |
713 | } | |
714 | ||
715 | ||
716 | void TestIDNA::testIDNToUnicode(const char* testName, TestFunc func){ | |
717 | int32_t i; | |
718 | UChar buf[MAX_DEST_SIZE]; | |
719 | UChar expected[MAX_DEST_SIZE]; | |
720 | UErrorCode status = U_ZERO_ERROR; | |
721 | int32_t bufLen = 0; | |
722 | UParseError parseError; | |
723 | for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ | |
374ca955 | 724 | bufLen = (int32_t)strlen(domainNames[i]); |
b75a7d8f A |
725 | bufLen = u_unescape(domainNames[i],buf, bufLen+1); |
726 | func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status); | |
727 | if(U_FAILURE(status)){ | |
729e4ab9 | 728 | errcheckln(status, "%s failed to convert domainNames[%i].Error: %s",testName, i, u_errorName(status)); |
b75a7d8f A |
729 | break; |
730 | } | |
731 | testAPI(buf,expected,testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
732 | //test toUnicode with all labels in the string | |
733 | testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
734 | if(U_FAILURE(status)){ | |
735 | errln( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status)); | |
736 | break; | |
737 | } | |
738 | } | |
739 | ||
740 | } | |
741 | ||
742 | void TestIDNA::testIDNToASCII(const char* testName, TestFunc func){ | |
743 | int32_t i; | |
744 | UChar buf[MAX_DEST_SIZE]; | |
745 | UChar expected[MAX_DEST_SIZE]; | |
746 | UErrorCode status = U_ZERO_ERROR; | |
747 | int32_t bufLen = 0; | |
748 | UParseError parseError; | |
749 | for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ | |
374ca955 | 750 | bufLen = (int32_t)strlen(domainNames[i]); |
b75a7d8f A |
751 | bufLen = u_unescape(domainNames[i],buf, bufLen+1); |
752 | func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status); | |
753 | if(U_FAILURE(status)){ | |
729e4ab9 | 754 | errcheckln(status, "%s failed to convert domainNames[%i].Error: %s",testName,i, u_errorName(status)); |
b75a7d8f A |
755 | break; |
756 | } | |
757 | testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
758 | //test toASCII with all labels in the string | |
759 | testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func); | |
760 | if(U_FAILURE(status)){ | |
761 | errln( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status)); | |
762 | break; | |
763 | } | |
764 | } | |
765 | ||
766 | } | |
767 | ||
768 | void TestIDNA::testCompare(const char* testName, CompareFunc func){ | |
769 | int32_t i; | |
770 | ||
771 | ||
772 | UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
773 | UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x0000}; | |
774 | UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
775 | ||
776 | UnicodeString source(www), uni0(www),uni1(www), ascii0(www), ascii1(www); | |
777 | ||
778 | uni0.append(unicodeIn[0]); | |
779 | uni0.append(com); | |
780 | uni0.append((UChar)0x0000); | |
781 | ||
782 | uni1.append(unicodeIn[1]); | |
783 | uni1.append(com); | |
784 | uni1.append((UChar)0x0000); | |
785 | ||
786 | ascii0.append(asciiIn[0]); | |
787 | ascii0.append(com); | |
788 | ascii0.append((UChar)0x0000); | |
789 | ||
790 | ascii1.append(asciiIn[1]); | |
791 | ascii1.append(com); | |
792 | ascii1.append((UChar)0x0000); | |
793 | ||
794 | for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
795 | ||
374ca955 | 796 | u_charsToUChars(asciiIn[i],buf+4, (int32_t)(strlen(asciiIn[i])+1)); |
b75a7d8f A |
797 | u_strcat(buf,com); |
798 | ||
799 | // for every entry in unicodeIn array | |
800 | // prepend www. and append .com | |
801 | source.truncate(4); | |
802 | source.append(unicodeIn[i]); | |
803 | source.append(com); | |
804 | source.append((UChar)0x0000); | |
805 | // a) compare it with itself | |
806 | const UChar* src = source.getBuffer(); | |
807 | int32_t srcLen = u_strlen(src); //subtract null | |
808 | ||
809 | testCompare(src,srcLen,src,srcLen,testName, func, TRUE); | |
810 | ||
811 | // b) compare it with asciiIn equivalent | |
812 | testCompare(src,srcLen,buf,u_strlen(buf),testName, func,TRUE); | |
813 | ||
814 | // c) compare it with unicodeIn not equivalent | |
815 | if(i==0){ | |
816 | testCompare(src,srcLen,uni1.getBuffer(),uni1.length()-1,testName, func,FALSE); | |
b75a7d8f A |
817 | }else{ |
818 | testCompare(src,srcLen,uni0.getBuffer(),uni0.length()-1,testName, func,FALSE); | |
b75a7d8f A |
819 | } |
820 | // d) compare it with asciiIn not equivalent | |
821 | if(i==0){ | |
822 | testCompare(src,srcLen,ascii1.getBuffer(),ascii1.length()-1,testName, func,FALSE); | |
b75a7d8f A |
823 | }else{ |
824 | testCompare(src,srcLen,ascii0.getBuffer(),ascii0.length()-1,testName, func,FALSE); | |
b75a7d8f A |
825 | } |
826 | ||
827 | } | |
828 | } | |
829 | ||
830 | #if 0 | |
831 | ||
832 | static int32_t | |
833 | getNextSeperator(UChar *src,int32_t srcLength, | |
834 | UChar **limit){ | |
835 | if(srcLength == -1){ | |
836 | int32_t i; | |
837 | for(i=0 ; ;i++){ | |
838 | if(src[i] == 0){ | |
839 | *limit = src + i; // point to null | |
840 | return i; | |
841 | } | |
842 | if(src[i]==0x002e){ | |
843 | *limit = src + (i+1); // go past the delimiter | |
844 | return i; | |
845 | } | |
846 | } | |
847 | // we have not found the delimiter | |
848 | if(i==srcLength){ | |
849 | *limit = src+srcLength; | |
850 | } | |
851 | return i; | |
852 | }else{ | |
853 | int32_t i; | |
854 | for(i=0;i<srcLength;i++){ | |
855 | if(src[i]==0x002e){ | |
856 | *limit = src + (i+1); // go past the delimiter | |
857 | return i; | |
858 | } | |
859 | } | |
860 | // we have not found the delimiter | |
861 | if(i==srcLength){ | |
862 | *limit = src+srcLength; | |
863 | } | |
864 | return i; | |
865 | } | |
866 | } | |
867 | ||
868 | void printPunycodeOutput(){ | |
869 | ||
870 | UChar dest[MAX_DEST_SIZE]; | |
871 | int32_t destCapacity=MAX_DEST_SIZE; | |
872 | UChar* start; | |
873 | UChar* limit; | |
874 | int32_t labelLen=0; | |
875 | UBool caseFlags[MAX_DEST_SIZE]; | |
876 | ||
877 | for(int32_t i=0;i< sizeof(errorCases)/sizeof(errorCases[0]);i++){ | |
878 | ErrorCases errorCase = errorCases[i]; | |
879 | UErrorCode status = U_ZERO_ERROR; | |
880 | start = errorCase.unicode; | |
881 | int32_t srcLen = u_strlen(start); | |
882 | labelLen = getNextSeperator(start,srcLen,&limit); | |
883 | start = limit; | |
884 | labelLen=getNextSeperator(start,srcLen-labelLen,&limit); | |
885 | int32_t destLen = u_strToPunycode(dest,destCapacity,start,labelLen,caseFlags, &status); | |
886 | if(U_FAILURE(status)){ | |
887 | printf("u_strToPunycode failed for index %i\n",i); | |
888 | continue; | |
889 | } | |
890 | for(int32_t j=0; j<destLen; j++){ | |
891 | printf("%c",(char)dest[j]); | |
892 | } | |
893 | printf("\n"); | |
894 | } | |
895 | } | |
896 | #endif | |
897 | ||
374ca955 A |
898 | void TestIDNA::testErrorCases(const char* IDNToASCIIName, TestFunc IDNToASCII, |
899 | const char* IDNToUnicodeName, TestFunc IDNToUnicode){ | |
b75a7d8f A |
900 | UChar buf[MAX_DEST_SIZE]; |
901 | int32_t bufLen=0; | |
902 | ||
903 | for(int32_t i=0;i< (int32_t)(sizeof(errorCases)/sizeof(errorCases[0]));i++){ | |
904 | ErrorCases errorCase = errorCases[i]; | |
905 | UChar* src =NULL; | |
906 | if(errorCase.ascii != NULL){ | |
374ca955 | 907 | bufLen = (int32_t)strlen(errorCase.ascii); |
b75a7d8f A |
908 | u_charsToUChars(errorCase.ascii,buf, bufLen+1); |
909 | }else{ | |
910 | bufLen = 1 ; | |
911 | memset(buf,0,U_SIZEOF_UCHAR*MAX_DEST_SIZE); | |
912 | } | |
913 | ||
914 | if(errorCase.unicode[0]!=0){ | |
915 | src = errorCase.unicode; | |
916 | } | |
917 | // test toASCII | |
918 | testAPI(src,buf, | |
919 | IDNToASCIIName, errorCase.useSTD3ASCIIRules, | |
920 | errorCase.expected, TRUE, TRUE, IDNToASCII); | |
921 | if(errorCase.testLabel ==TRUE){ | |
922 | testAPI(src,buf, | |
374ca955 A |
923 | IDNToASCIIName, errorCase.useSTD3ASCIIRules, |
924 | errorCase.expected, FALSE,TRUE, IDNToASCII); | |
b75a7d8f A |
925 | } |
926 | if(errorCase.testToUnicode ==TRUE){ | |
927 | testAPI((src==NULL)? NULL : buf,src, | |
928 | IDNToUnicodeName, errorCase.useSTD3ASCIIRules, | |
929 | errorCase.expected, TRUE, TRUE, IDNToUnicode); | |
930 | } | |
931 | ||
932 | } | |
933 | ||
934 | } | |
46f4442e | 935 | /* |
b75a7d8f A |
936 | void TestIDNA::testConformance(const char* toASCIIName, TestFunc toASCII, |
937 | const char* IDNToASCIIName, TestFunc IDNToASCII, | |
938 | const char* IDNToUnicodeName, TestFunc IDNToUnicode, | |
939 | const char* toUnicodeName, TestFunc toUnicode){ | |
940 | UChar src[MAX_DEST_SIZE]; | |
941 | int32_t srcLen=0; | |
942 | UChar expected[MAX_DEST_SIZE]; | |
943 | int32_t expectedLen = 0; | |
944 | for(int32_t i=0;i< (int32_t)(sizeof(conformanceTestCases)/sizeof(conformanceTestCases[0]));i++){ | |
945 | const char* utf8Chars1 = conformanceTestCases[i].in; | |
374ca955 | 946 | int32_t utf8Chars1Len = (int32_t)strlen(utf8Chars1); |
b75a7d8f | 947 | const char* utf8Chars2 = conformanceTestCases[i].out; |
374ca955 | 948 | int32_t utf8Chars2Len = (utf8Chars2 == NULL) ? 0 : (int32_t)strlen(utf8Chars2); |
b75a7d8f A |
949 | |
950 | UErrorCode status = U_ZERO_ERROR; | |
951 | u_strFromUTF8(src,MAX_DEST_SIZE,&srcLen,utf8Chars1,utf8Chars1Len,&status); | |
952 | if(U_FAILURE(status)){ | |
953 | errln(UnicodeString("Conversion of UTF8 source in conformanceTestCases[") + i +UnicodeString( "].in ( ")+prettify(utf8Chars1) +UnicodeString(" ) failed. Error: ")+ UnicodeString(u_errorName(status))); | |
954 | continue; | |
955 | } | |
956 | if(utf8Chars2 != NULL){ | |
957 | u_strFromUTF8(expected,MAX_DEST_SIZE,&expectedLen,utf8Chars2,utf8Chars2Len, &status); | |
958 | if(U_FAILURE(status)){ | |
959 | errln(UnicodeString("Conversion of UTF8 source in conformanceTestCases[") + i +UnicodeString( "].in ( ")+prettify(utf8Chars1) +UnicodeString(" ) failed. Error: ")+ UnicodeString(u_errorName(status))); | |
960 | continue; | |
961 | } | |
962 | } | |
963 | ||
964 | if(conformanceTestCases[i].expectedStatus != U_ZERO_ERROR){ | |
965 | // test toASCII | |
966 | testAPI(src,expected, | |
967 | IDNToASCIIName, FALSE, | |
968 | conformanceTestCases[i].expectedStatus, | |
969 | TRUE, | |
374ca955 | 970 | (conformanceTestCases[i].expectedStatus != U_IDNA_UNASSIGNED_ERROR), |
b75a7d8f A |
971 | IDNToASCII); |
972 | ||
973 | testAPI(src,expected, | |
974 | toASCIIName, FALSE, | |
975 | conformanceTestCases[i].expectedStatus, TRUE, | |
374ca955 | 976 | (conformanceTestCases[i].expectedStatus != U_IDNA_UNASSIGNED_ERROR), |
b75a7d8f A |
977 | toASCII); |
978 | } | |
979 | ||
980 | testAPI(src,src, | |
981 | IDNToUnicodeName, FALSE, | |
982 | conformanceTestCases[i].expectedStatus, TRUE, TRUE, IDNToUnicode); | |
983 | testAPI(src,src, | |
984 | toUnicodeName, FALSE, | |
985 | conformanceTestCases[i].expectedStatus, TRUE, TRUE, toUnicode); | |
986 | ||
987 | } | |
988 | ||
989 | } | |
46f4442e | 990 | */ |
b75a7d8f A |
991 | // test and ascertain |
992 | // func(func(func(src))) == func(src) | |
46f4442e | 993 | void TestIDNA::testChaining(const UChar* src,int32_t numIterations,const char* testName, |
b75a7d8f A |
994 | UBool useSTD3ASCIIRules, UBool caseInsensitive, TestFunc func){ |
995 | UChar even[MAX_DEST_SIZE]; | |
996 | UChar odd[MAX_DEST_SIZE]; | |
997 | UChar expected[MAX_DEST_SIZE]; | |
998 | int32_t i=0,evenLen=0,oddLen=0,expectedLen=0; | |
999 | UErrorCode status = U_ZERO_ERROR; | |
1000 | int32_t srcLen = u_strlen(src); | |
1001 | int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT; | |
1002 | UParseError parseError; | |
1003 | ||
1004 | // test null-terminated source | |
1005 | expectedLen = func(src,-1,expected,MAX_DEST_SIZE, options, &parseError, &status); | |
1006 | if(U_FAILURE(status)){ | |
729e4ab9 | 1007 | errcheckln(status, "%s null terminated source failed. Error: %s",testName, u_errorName(status)); |
b75a7d8f | 1008 | } |
374ca955 A |
1009 | memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); |
1010 | memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); | |
b75a7d8f A |
1011 | for(;i<=numIterations; i++){ |
1012 | if((i%2) ==0){ | |
1013 | evenLen = func(odd,-1,even,MAX_DEST_SIZE,options, &parseError, &status); | |
1014 | if(U_FAILURE(status)){ | |
729e4ab9 | 1015 | errcheckln(status, "%s null terminated source failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1016 | break; |
1017 | } | |
1018 | }else{ | |
1019 | oddLen = func(even,-1,odd,MAX_DEST_SIZE,options, &parseError, &status); | |
1020 | if(U_FAILURE(status)){ | |
1021 | errln("%s null terminated source failed\n",testName); | |
1022 | break; | |
1023 | } | |
1024 | } | |
1025 | } | |
1026 | if(caseInsensitive ==TRUE){ | |
1027 | if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || | |
1028 | u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ | |
1029 | ||
1030 | errln("Chaining for %s null terminated source failed\n",testName); | |
1031 | } | |
1032 | }else{ | |
1033 | if( u_strncmp(even,expected,expectedLen) != 0 || | |
1034 | u_strncmp(odd,expected,expectedLen) !=0 ){ | |
1035 | ||
1036 | errln("Chaining for %s null terminated source failed\n",testName); | |
1037 | } | |
1038 | } | |
1039 | ||
1040 | // test null-terminated source | |
1041 | status = U_ZERO_ERROR; | |
1042 | expectedLen = func(src,-1,expected,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1043 | if(U_FAILURE(status)){ | |
729e4ab9 | 1044 | errcheckln(status, "%s null terminated source with options set failed. Error: %s",testName, u_errorName(status)); |
b75a7d8f | 1045 | } |
374ca955 A |
1046 | memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); |
1047 | memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); | |
b75a7d8f A |
1048 | for(;i<=numIterations; i++){ |
1049 | if((i%2) ==0){ | |
1050 | evenLen = func(odd,-1,even,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1051 | if(U_FAILURE(status)){ | |
729e4ab9 | 1052 | errcheckln(status, "%s null terminated source with options set failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1053 | break; |
1054 | } | |
1055 | }else{ | |
1056 | oddLen = func(even,-1,odd,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1057 | if(U_FAILURE(status)){ | |
1058 | errln("%s null terminated source with options set failed\n",testName); | |
1059 | break; | |
1060 | } | |
1061 | } | |
1062 | } | |
1063 | if(caseInsensitive ==TRUE){ | |
1064 | if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || | |
1065 | u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ | |
1066 | ||
1067 | errln("Chaining for %s null terminated source with options set failed\n",testName); | |
1068 | } | |
1069 | }else{ | |
1070 | if( u_strncmp(even,expected,expectedLen) != 0 || | |
1071 | u_strncmp(odd,expected,expectedLen) !=0 ){ | |
1072 | ||
1073 | errln("Chaining for %s null terminated source with options set failed\n",testName); | |
1074 | } | |
1075 | } | |
1076 | ||
1077 | ||
1078 | // test source with length | |
1079 | status = U_ZERO_ERROR; | |
1080 | expectedLen = func(src,srcLen,expected,MAX_DEST_SIZE,options, &parseError, &status); | |
1081 | if(U_FAILURE(status)){ | |
729e4ab9 | 1082 | errcheckln(status, "%s null terminated source failed. Error: %s",testName, u_errorName(status)); |
b75a7d8f | 1083 | } |
374ca955 A |
1084 | memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); |
1085 | memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); | |
b75a7d8f A |
1086 | for(;i<=numIterations; i++){ |
1087 | if((i%2) ==0){ | |
1088 | evenLen = func(odd,oddLen,even,MAX_DEST_SIZE,options, &parseError, &status); | |
1089 | if(U_FAILURE(status)){ | |
729e4ab9 | 1090 | errcheckln(status, "%s source with source length failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1091 | break; |
1092 | } | |
1093 | }else{ | |
1094 | oddLen = func(even,evenLen,odd,MAX_DEST_SIZE,options, &parseError, &status); | |
1095 | if(U_FAILURE(status)){ | |
729e4ab9 | 1096 | errcheckln(status, "%s source with source length failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1097 | break; |
1098 | } | |
1099 | } | |
1100 | } | |
1101 | if(caseInsensitive ==TRUE){ | |
1102 | if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || | |
1103 | u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ | |
1104 | ||
1105 | errln("Chaining for %s source with source length failed\n",testName); | |
1106 | } | |
1107 | }else{ | |
1108 | if( u_strncmp(even,expected,expectedLen) != 0 || | |
1109 | u_strncmp(odd,expected,expectedLen) !=0 ){ | |
1110 | ||
1111 | errln("Chaining for %s source with source length failed\n",testName); | |
1112 | } | |
1113 | } | |
1114 | status = U_ZERO_ERROR; | |
1115 | expectedLen = func(src,srcLen,expected,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1116 | if(U_FAILURE(status)){ | |
729e4ab9 | 1117 | errcheckln(status, "%s null terminated source with options set failed. Error: %s",testName, u_errorName(status)); |
b75a7d8f | 1118 | } |
374ca955 A |
1119 | memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); |
1120 | memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); | |
b75a7d8f A |
1121 | for(;i<=numIterations; i++){ |
1122 | if((i%2) ==0){ | |
1123 | evenLen = func(odd,oddLen,even,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1124 | if(U_FAILURE(status)){ | |
729e4ab9 | 1125 | errcheckln(status, "%s source with source length and options set failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1126 | break; |
1127 | } | |
1128 | }else{ | |
1129 | oddLen = func(even,evenLen,odd,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); | |
1130 | if(U_FAILURE(status)){ | |
729e4ab9 | 1131 | errcheckln(status, "%s source with source length and options set failed - %s",testName, u_errorName(status)); |
b75a7d8f A |
1132 | break; |
1133 | } | |
1134 | } | |
1135 | } | |
1136 | if(caseInsensitive ==TRUE){ | |
1137 | if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || | |
1138 | u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ | |
1139 | ||
1140 | errln("Chaining for %s source with source length and options set failed\n",testName); | |
1141 | } | |
1142 | }else{ | |
1143 | if( u_strncmp(even,expected,expectedLen) != 0 || | |
1144 | u_strncmp(odd,expected,expectedLen) !=0 ){ | |
1145 | ||
1146 | errln("Chaining for %s source with source length and options set failed\n",testName); | |
1147 | } | |
1148 | } | |
1149 | } | |
1150 | void TestIDNA::testChaining(const char* toASCIIName, TestFunc toASCII, | |
1151 | const char* toUnicodeName, TestFunc toUnicode){ | |
1152 | int32_t i; | |
1153 | UChar buf[MAX_DEST_SIZE]; | |
1154 | ||
1155 | for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){ | |
374ca955 | 1156 | u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); |
b75a7d8f A |
1157 | testChaining(buf,5,toUnicodeName, FALSE, FALSE, toUnicode); |
1158 | } | |
1159 | for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
1160 | testChaining(unicodeIn[i], 5,toASCIIName, FALSE, TRUE, toASCII); | |
1161 | } | |
1162 | } | |
1163 | ||
1164 | ||
1165 | void TestIDNA::testRootLabelSeparator(const char* testName, CompareFunc func, | |
1166 | const char* IDNToASCIIName, TestFunc IDNToASCII, | |
1167 | const char* IDNToUnicodeName, TestFunc IDNToUnicode){ | |
1168 | int32_t i; | |
1169 | ||
1170 | ||
1171 | UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
1172 | UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x002E, /* root label separator */0x0000}; | |
1173 | UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
1174 | ||
1175 | UnicodeString source(www), uni0(www),uni1(www), ascii0(www), ascii1(www); | |
1176 | ||
1177 | uni0.append(unicodeIn[0]); | |
1178 | uni0.append(com); | |
1179 | uni0.append((UChar)0x0000); | |
1180 | ||
1181 | uni1.append(unicodeIn[1]); | |
1182 | uni1.append(com); | |
1183 | uni1.append((UChar)0x0000); | |
1184 | ||
1185 | ascii0.append(asciiIn[0]); | |
1186 | ascii0.append(com); | |
1187 | ascii0.append((UChar)0x0000); | |
1188 | ||
1189 | ascii1.append(asciiIn[1]); | |
1190 | ascii1.append(com); | |
1191 | ascii1.append((UChar)0x0000); | |
1192 | ||
1193 | for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
1194 | ||
374ca955 | 1195 | u_charsToUChars(asciiIn[i],buf+4, (int32_t)(strlen(asciiIn[i])+1)); |
b75a7d8f A |
1196 | u_strcat(buf,com); |
1197 | ||
1198 | // for every entry in unicodeIn array | |
1199 | // prepend www. and append .com | |
1200 | source.truncate(4); | |
1201 | source.append(unicodeIn[i]); | |
1202 | source.append(com); | |
1203 | source.append((UChar)0x0000); | |
374ca955 | 1204 | |
b75a7d8f A |
1205 | const UChar* src = source.getBuffer(); |
1206 | int32_t srcLen = u_strlen(src); //subtract null | |
b75a7d8f A |
1207 | |
1208 | // b) compare it with asciiIn equivalent | |
1209 | testCompare(src,srcLen,buf,u_strlen(buf),testName, func,TRUE); | |
1210 | ||
374ca955 A |
1211 | // a) compare it with itself |
1212 | testCompare(src,srcLen,src,srcLen,testName, func,TRUE); | |
1213 | ||
1214 | ||
b75a7d8f A |
1215 | // IDNToASCII comparison |
1216 | testAPI(src,buf,IDNToASCIIName,FALSE,U_ZERO_ERROR,TRUE, TRUE, IDNToASCII); | |
1217 | // IDNToUnicode comparison | |
1218 | testAPI(buf,src,IDNToUnicodeName, FALSE,U_ZERO_ERROR, TRUE, TRUE, IDNToUnicode); | |
1219 | ||
1220 | // c) compare it with unicodeIn not equivalent | |
1221 | if(i==0){ | |
1222 | testCompare(src,srcLen,uni1.getBuffer(),uni1.length()-1,testName, func,FALSE); | |
b75a7d8f A |
1223 | }else{ |
1224 | testCompare(src,srcLen,uni0.getBuffer(),uni0.length()-1,testName, func,FALSE); | |
b75a7d8f A |
1225 | } |
1226 | // d) compare it with asciiIn not equivalent | |
1227 | if(i==0){ | |
1228 | testCompare(src,srcLen,ascii1.getBuffer(),ascii1.length()-1,testName, func,FALSE); | |
b75a7d8f A |
1229 | }else{ |
1230 | testCompare(src,srcLen,ascii0.getBuffer(),ascii0.length()-1,testName, func,FALSE); | |
b75a7d8f A |
1231 | } |
1232 | } | |
1233 | } | |
1234 | ||
1235 | //--------------------------------------------- | |
1236 | // runIndexedTest | |
1237 | //--------------------------------------------- | |
1238 | ||
729e4ab9 A |
1239 | extern IntlTest *createUTS46Test(); |
1240 | ||
73c04bcf | 1241 | void TestIDNA::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par) |
b75a7d8f A |
1242 | { |
1243 | if (exec) logln((UnicodeString)"TestSuite IDNA API "); | |
1244 | switch (index) { | |
1245 | ||
1246 | case 0: name = "TestToASCII"; if (exec) TestToASCII(); break; | |
1247 | case 1: name = "TestToUnicode"; if (exec) TestToUnicode(); break; | |
1248 | case 2: name = "TestIDNToASCII"; if (exec) TestIDNToASCII(); break; | |
1249 | case 3: name = "TestIDNToUnicode"; if (exec) TestIDNToUnicode(); break; | |
1250 | case 4: name = "TestCompare"; if (exec) TestCompare(); break; | |
1251 | case 5: name = "TestErrorCases"; if (exec) TestErrorCases(); break; | |
1252 | case 6: name = "TestChaining"; if (exec) TestChaining(); break; | |
1253 | case 7: name = "TestRootLabelSeparator"; if(exec) TestRootLabelSeparator(); break; | |
1254 | case 8: name = "TestCompareReferenceImpl"; if(exec) TestCompareReferenceImpl(); break; | |
1255 | case 9: name = "TestDataFile"; if(exec) TestDataFile(); break; | |
729e4ab9 | 1256 | #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
b75a7d8f A |
1257 | case 10: name = "TestRefIDNA"; if(exec) TestRefIDNA(); break; |
1258 | case 11: name = "TestIDNAMonkeyTest"; if(exec) TestIDNAMonkeyTest(); break; | |
729e4ab9 A |
1259 | #else |
1260 | case 10: case 11: name = "skip"; break; | |
1261 | #endif | |
46f4442e | 1262 | case 12: |
73c04bcf A |
1263 | { |
1264 | name = "TestConformanceTestVectors"; | |
1265 | if(exec){ | |
1266 | logln("TestSuite IDNA conf----"); logln(); | |
1267 | IdnaConfTest test; | |
1268 | callTest(test, par); | |
1269 | } | |
1270 | break; | |
1271 | } | |
729e4ab9 A |
1272 | case 13: |
1273 | name = "UTS46Test"; | |
1274 | if (exec) { | |
1275 | logln("TestSuite UTS46Test---"); logln(); | |
1276 | LocalPointer<IntlTest> test(createUTS46Test()); | |
1277 | callTest(*test, par); | |
1278 | } | |
1279 | break; | |
b75a7d8f A |
1280 | default: name = ""; break; /*needed to end loop*/ |
1281 | } | |
1282 | } | |
1283 | void TestIDNA::TestToASCII(){ | |
1284 | testToASCII("uidna_toASCII", uidna_toASCII); | |
1285 | } | |
1286 | void TestIDNA::TestToUnicode(){ | |
1287 | testToUnicode("uidna_toUnicode", uidna_toUnicode); | |
1288 | } | |
1289 | void TestIDNA::TestIDNToASCII(){ | |
1290 | testIDNToASCII("uidna_IDNToASCII", uidna_IDNToASCII); | |
1291 | } | |
1292 | void TestIDNA::TestIDNToUnicode(){ | |
1293 | testIDNToUnicode("uidna_IDNToUnicode", uidna_IDNToUnicode); | |
1294 | } | |
1295 | void TestIDNA::TestCompare(){ | |
1296 | testCompare("uidna_compare",uidna_compare); | |
1297 | } | |
1298 | void TestIDNA::TestErrorCases(){ | |
374ca955 | 1299 | testErrorCases( "uidna_IDNToASCII",uidna_IDNToASCII, |
b75a7d8f A |
1300 | "uidna_IDNToUnicode",uidna_IDNToUnicode); |
1301 | } | |
1302 | void TestIDNA::TestRootLabelSeparator(){ | |
1303 | testRootLabelSeparator( "uidna_compare",uidna_compare, | |
1304 | "uidna_IDNToASCII", uidna_IDNToASCII, | |
1305 | "uidna_IDNToUnicode",uidna_IDNToUnicode | |
1306 | ); | |
1307 | } | |
1308 | void TestIDNA::TestChaining(){ | |
1309 | testChaining("uidna_toASCII",uidna_toASCII, "uidna_toUnicode", uidna_toUnicode); | |
1310 | } | |
46f4442e | 1311 | |
b75a7d8f A |
1312 | |
1313 | static const int loopCount = 100; | |
1314 | static const int maxCharCount = 20; | |
1315 | static const int maxCodePoint = 0x10ffff; | |
1316 | static uint32_t | |
1317 | randul() | |
1318 | { | |
1319 | static UBool initialized = FALSE; | |
1320 | if (!initialized) | |
1321 | { | |
1322 | srand((unsigned)time(NULL)); | |
1323 | initialized = TRUE; | |
1324 | } | |
1325 | // Assume rand has at least 12 bits of precision | |
1326 | uint32_t l = 0; | |
1327 | for (uint32_t i=0; i<sizeof(l); ++i) | |
1328 | ((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4); | |
1329 | return l; | |
1330 | } | |
1331 | ||
1332 | /** | |
1333 | * Return a random integer i where 0 <= i < n. | |
1334 | * A special function that gets random codepoints from planes 0,1,2 and 14 | |
1335 | */ | |
1336 | static int32_t rand_uni() | |
1337 | { | |
1338 | int32_t retVal = (int32_t)(randul()& 0x3FFFF); | |
1339 | if(retVal >= 0x30000){ | |
1340 | retVal+=0xB0000; | |
1341 | } | |
1342 | return retVal; | |
1343 | } | |
1344 | ||
1345 | static int32_t randi(int32_t n){ | |
1346 | return (int32_t) (randul() % (n+1)); | |
1347 | } | |
1348 | ||
1349 | void getTestSource(UnicodeString& fillIn) { | |
1350 | int32_t i = 0; | |
1351 | int32_t charCount = (randi(maxCharCount) + 1); | |
1352 | while (i <charCount ) { | |
1353 | int32_t codepoint = rand_uni(); | |
1354 | if(codepoint == 0x0000){ | |
1355 | continue; | |
1356 | } | |
1357 | fillIn.append((UChar32)codepoint); | |
1358 | i++; | |
1359 | } | |
1360 | ||
1361 | } | |
374ca955 A |
1362 | |
1363 | UnicodeString TestIDNA::testCompareReferenceImpl(UnicodeString& src, | |
1364 | TestFunc refIDNA, const char* refIDNAName, | |
1365 | TestFunc uIDNA, const char* uIDNAName, | |
1366 | int32_t options){ | |
1367 | ||
1368 | const UChar* srcUChars = src.getBuffer(); | |
1369 | UChar exp[MAX_DEST_SIZE]={0}; | |
1370 | int32_t expCap = MAX_DEST_SIZE, expLen=0; | |
1371 | UErrorCode expStatus = U_ZERO_ERROR; | |
1372 | UParseError parseError; | |
1373 | ||
1374 | logln("Comparing "+ UnicodeString(refIDNAName) | |
1375 | + " with "+ UnicodeString(uIDNAName) | |
1376 | +" for input: " + prettify(srcUChars)); | |
b75a7d8f | 1377 | |
374ca955 A |
1378 | expLen = refIDNA(srcUChars, src.length()-1, exp, expCap, |
1379 | options, &parseError, &expStatus); | |
1380 | ||
1381 | UChar got[MAX_DEST_SIZE]={0}; | |
1382 | int32_t gotCap = MAX_DEST_SIZE, gotLen=0; | |
1383 | UErrorCode gotStatus = U_ZERO_ERROR; | |
1384 | ||
1385 | gotLen = uIDNA(srcUChars, src.length()-1, got, gotCap, | |
1386 | options, &parseError, &gotStatus); | |
1387 | ||
1388 | if(expStatus != gotStatus){ | |
1389 | errln("Did not get the expected status while comparing " + UnicodeString(refIDNAName) | |
1390 | + " with " + UnicodeString(uIDNAName) | |
1391 | + " Expected: " + UnicodeString(u_errorName(expStatus)) | |
1392 | + " Got: " + UnicodeString(u_errorName(gotStatus)) | |
1393 | + " for Source: "+ prettify(srcUChars) | |
1394 | + " Options: " + options); | |
374ca955 A |
1395 | return UnicodeString(""); |
1396 | } | |
b75a7d8f | 1397 | |
374ca955 A |
1398 | // now we know that both implementations yielded same error |
1399 | if(U_SUCCESS(expStatus)){ | |
1400 | // compare the outputs if status == U_ZERO_ERROR | |
1401 | if(u_strCompare(exp, expLen, got, gotLen, TRUE) != 0){ | |
1402 | errln("Did not get the expected output while comparing " + UnicodeString(refIDNAName) | |
1403 | + " with " + UnicodeString(uIDNAName) | |
1404 | + " Expected: " + prettify(UnicodeString(exp, expLen)) | |
1405 | + " Got: " + prettify(UnicodeString(got, gotLen)) | |
1406 | + " for Source: "+ prettify(srcUChars) | |
1407 | + " Options: " + options); | |
b75a7d8f | 1408 | } |
374ca955 | 1409 | return UnicodeString(exp, expLen); |
b75a7d8f | 1410 | |
374ca955 A |
1411 | }else{ |
1412 | logln("Got the same error while comparing " | |
1413 | + UnicodeString(refIDNAName) | |
1414 | + " with "+ UnicodeString(uIDNAName) | |
1415 | +" for input: " + prettify(srcUChars)); | |
1416 | } | |
374ca955 A |
1417 | return UnicodeString(""); |
1418 | } | |
1419 | ||
1420 | void TestIDNA::testCompareReferenceImpl(const UChar* src, int32_t srcLen){ | |
1421 | UnicodeString label(src,srcLen); | |
1422 | label.append((UChar)0x0000); | |
1423 | ||
1424 | //test idnaref_toASCII and idnare | |
1425 | UnicodeString asciiLabel = testCompareReferenceImpl(label, | |
1426 | idnaref_toASCII, "idnaref_toASCII", | |
1427 | uidna_toASCII, "uidna_toASCII", | |
1428 | UIDNA_ALLOW_UNASSIGNED); | |
1429 | testCompareReferenceImpl(label, | |
1430 | idnaref_toASCII, "idnaref_toASCII", | |
1431 | uidna_toASCII, "uidna_toASCII", | |
1432 | UIDNA_DEFAULT); | |
1433 | testCompareReferenceImpl(label, | |
1434 | idnaref_toASCII, "idnaref_toASCII", | |
1435 | uidna_toASCII, "uidna_toASCII", | |
1436 | UIDNA_USE_STD3_RULES); | |
1437 | testCompareReferenceImpl(label, | |
1438 | idnaref_toASCII, "idnaref_toASCII", | |
1439 | uidna_toASCII, "uidna_toASCII", | |
1440 | UIDNA_USE_STD3_RULES | UIDNA_ALLOW_UNASSIGNED); | |
1441 | ||
1442 | if(asciiLabel.length()!=0){ | |
1443 | asciiLabel.append((UChar)0x0000); | |
1444 | ||
1445 | // test toUnciode | |
1446 | testCompareReferenceImpl(asciiLabel, | |
1447 | idnaref_toUnicode, "idnaref_toUnicode", | |
1448 | uidna_toUnicode, "uidna_toUnicode", | |
1449 | UIDNA_ALLOW_UNASSIGNED); | |
1450 | testCompareReferenceImpl(asciiLabel, | |
1451 | idnaref_toUnicode, "idnaref_toUnicode", | |
1452 | uidna_toUnicode, "uidna_toUnicode", | |
1453 | UIDNA_DEFAULT); | |
1454 | testCompareReferenceImpl(asciiLabel, | |
1455 | idnaref_toUnicode, "idnaref_toUnicode", | |
1456 | uidna_toUnicode, "uidna_toUnicode", | |
1457 | UIDNA_USE_STD3_RULES); | |
1458 | testCompareReferenceImpl(asciiLabel, | |
1459 | idnaref_toUnicode, "idnaref_toUnicode", | |
1460 | uidna_toUnicode, "uidna_toUnicode", | |
1461 | UIDNA_USE_STD3_RULES | UIDNA_ALLOW_UNASSIGNED); | |
b75a7d8f A |
1462 | } |
1463 | ||
1464 | } | |
374ca955 A |
1465 | const char* failures[] ={ |
1466 | "\\uAA42\\U0001F8DD\\U00019D01\\U000149A3\\uD385\\U000EE0F5\\U00018B92\\U000179D1\\U00018624\\U0002227F\\U000E83C0\\U000E8DCD\\u5460\\U00017F34\\U0001570B\\u43D1\\U0002C9C9\\U000281EC\\u2105\\U000180AE\\uC5D4", | |
1467 | "\\U0002F5A6\\uD638\\u0D0A\\u9E9C\\uFE5B\\U0001FCCB\\u66C4", | |
1468 | }; | |
1469 | ||
b75a7d8f A |
1470 | void TestIDNA::TestIDNAMonkeyTest(){ |
1471 | UnicodeString source; | |
1472 | UErrorCode status = U_ZERO_ERROR; | |
374ca955 | 1473 | int i; |
b75a7d8f A |
1474 | |
1475 | getInstance(status); // Init prep | |
73c04bcf | 1476 | if (U_FAILURE(status)) { |
729e4ab9 | 1477 | dataerrln("Test could not initialize. Got %s", u_errorName(status)); |
73c04bcf A |
1478 | return; |
1479 | } | |
1480 | ||
374ca955 | 1481 | for(i=0; i<loopCount; i++){ |
b75a7d8f A |
1482 | source.truncate(0); |
1483 | getTestSource(source); | |
1484 | source.append((UChar)0x0000); | |
374ca955 A |
1485 | const UChar* src = source.getBuffer(); |
1486 | testCompareReferenceImpl(src,source.length()-1); | |
1487 | testCompareReferenceImpl(src,source.length()-1); | |
374ca955 A |
1488 | } |
1489 | ||
1490 | /* for debugging */ | |
1491 | for (i=0; i<(int)(sizeof(failures)/sizeof(failures[0])); i++){ | |
1492 | source.truncate(0); | |
46f4442e | 1493 | source.append( UnicodeString(failures[i], -1, US_INV) ); |
374ca955 A |
1494 | source = source.unescape(); |
1495 | source.append((UChar)0x0000); | |
1496 | const UChar *src = source.getBuffer(); | |
1497 | testCompareReferenceImpl(src,source.length()-1); | |
1498 | //debug(source.getBuffer(),source.length(),UIDNA_ALLOW_UNASSIGNED); | |
b75a7d8f | 1499 | } |
374ca955 A |
1500 | |
1501 | ||
1502 | source.truncate(0); | |
46f4442e | 1503 | source.append(UNICODE_STRING_SIMPLE("\\uCF18\\U00021161\\U000EEF11\\U0002BB82\\U0001D63C")); |
374ca955 | 1504 | debug(source.getBuffer(),source.length(),UIDNA_ALLOW_UNASSIGNED); |
374ca955 A |
1505 | |
1506 | { // test deletion of code points | |
46f4442e | 1507 | UnicodeString source("\\u043f\\u00AD\\u034f\\u043e\\u0447\\u0435\\u043c\\u0443\\u0436\\u0435\\u043e\\u043d\\u0438\\u043d\\u0435\\u0433\\u043e\\u0432\\u043e\\u0440\\u044f\\u0442\\u043f\\u043e\\u0440\\u0443\\u0441\\u0441\\u043a\\u0438\\u0000", -1, US_INV); |
374ca955 | 1508 | source = source.unescape(); |
46f4442e | 1509 | UnicodeString expected("\\u043f\\u043e\\u0447\\u0435\\u043c\\u0443\\u0436\\u0435\\u043e\\u043d\\u0438\\u043d\\u0435\\u0433\\u043e\\u0432\\u043e\\u0440\\u044f\\u0442\\u043f\\u043e\\u0440\\u0443\\u0441\\u0441\\u043a\\u0438\\u0000", -1, US_INV); |
374ca955 A |
1510 | expected = expected.unescape(); |
1511 | UnicodeString ascii("xn--b1abfaaepdrnnbgefbadotcwatmq2g4l"); | |
1512 | ascii.append((UChar)0x0000); | |
1513 | testAPI(source.getBuffer(),ascii.getBuffer(), "uidna_toASCII", FALSE, U_ZERO_ERROR, TRUE, TRUE, uidna_toASCII); | |
374ca955 A |
1514 | |
1515 | testAPI(source.getBuffer(),ascii.getBuffer(), "idnaref_toASCII", FALSE, U_ZERO_ERROR, TRUE, TRUE, idnaref_toASCII); | |
374ca955 A |
1516 | |
1517 | testCompareReferenceImpl(source.getBuffer(), source.length()-1); | |
374ca955 | 1518 | } |
b75a7d8f | 1519 | |
b75a7d8f A |
1520 | } |
1521 | ||
1522 | void TestIDNA::TestCompareReferenceImpl(){ | |
4388f060 | 1523 | |
b75a7d8f A |
1524 | UChar src [2] = {0,0}; |
1525 | int32_t srcLen = 0; | |
b75a7d8f | 1526 | |
51004dcb A |
1527 | // data even OK? |
1528 | { | |
1529 | UErrorCode dataStatus = U_ZERO_ERROR; | |
1530 | loadTestData(dataStatus); | |
1531 | if(U_FAILURE(dataStatus)) { | |
1532 | dataerrln("Couldn't load test data: %s\n", u_errorName(dataStatus)); // save us from thousands and thousands of errors | |
1533 | return; | |
1534 | } | |
1535 | } | |
4388f060 A |
1536 | |
1537 | for (int32_t i = 0; i <= 0x10FFFF; i++){ | |
1538 | if (quick == TRUE && i > 0x0FFF){ | |
b75a7d8f A |
1539 | return; |
1540 | } | |
4388f060 A |
1541 | if(i == 0x30000){ |
1542 | // jump to E0000, no characters assigned in plain 3 to plain 13 as of Unicode 6.0 | |
1543 | i = 0xE0000; | |
b75a7d8f | 1544 | } |
4388f060 A |
1545 | if (i > 0xFFFF){ |
1546 | src[0] = U16_LEAD(i); | |
1547 | src[1] = U16_TRAIL(i); | |
1548 | srcLen =2; | |
1549 | } else { | |
b75a7d8f A |
1550 | src[0] = (UChar)i; |
1551 | src[1] = 0; | |
1552 | srcLen = 1; | |
1553 | } | |
1554 | testCompareReferenceImpl(src, srcLen); | |
1555 | } | |
1556 | } | |
1557 | ||
1558 | void TestIDNA::TestRefIDNA(){ | |
73c04bcf A |
1559 | UErrorCode status = U_ZERO_ERROR; |
1560 | getInstance(status); // Init prep | |
1561 | if (U_FAILURE(status)) { | |
46f4442e | 1562 | if (status == U_FILE_ACCESS_ERROR) { |
729e4ab9 | 1563 | dataerrln("Test could not initialize. Got %s", u_errorName(status)); |
46f4442e | 1564 | } |
73c04bcf A |
1565 | return; |
1566 | } | |
1567 | ||
b75a7d8f A |
1568 | testToASCII("idnaref_toASCII", idnaref_toASCII); |
1569 | testToUnicode("idnaref_toUnicode", idnaref_toUnicode); | |
1570 | testIDNToASCII("idnaref_IDNToASCII", idnaref_IDNToASCII); | |
1571 | testIDNToUnicode("idnaref_IDNToUnicode", idnaref_IDNToUnicode); | |
1572 | testCompare("idnaref_compare",idnaref_compare); | |
374ca955 | 1573 | testErrorCases( "idnaref_IDNToASCII",idnaref_IDNToASCII, |
b75a7d8f A |
1574 | "idnaref_IDNToUnicode",idnaref_IDNToUnicode); |
1575 | testChaining("idnaref_toASCII",idnaref_toASCII, "idnaref_toUnicode", idnaref_toUnicode); | |
1576 | ||
1577 | testRootLabelSeparator( "idnaref_compare",idnaref_compare, | |
1578 | "idnaref_IDNToASCII", idnaref_IDNToASCII, | |
1579 | "idnaref_IDNToUnicode",idnaref_IDNToUnicode | |
1580 | ); | |
1581 | testChaining("idnaref_toASCII",idnaref_toASCII, "idnaref_toUnicode", idnaref_toUnicode); | |
b75a7d8f A |
1582 | } |
1583 | ||
73c04bcf | 1584 | |
b75a7d8f A |
1585 | void TestIDNA::TestDataFile(){ |
1586 | testData(*this); | |
1587 | } | |
374ca955 A |
1588 | TestIDNA::~TestIDNA(){ |
1589 | if(gPrep!=NULL){ | |
1590 | delete gPrep; | |
1591 | gPrep = NULL; | |
1592 | } | |
1593 | } | |
b75a7d8f | 1594 | |
374ca955 A |
1595 | NamePrepTransform* TestIDNA::gPrep = NULL; |
1596 | ||
1597 | NamePrepTransform* TestIDNA::getInstance(UErrorCode& status){ | |
1598 | if(TestIDNA::gPrep == NULL){ | |
1599 | UParseError parseError; | |
1600 | TestIDNA::gPrep = NamePrepTransform::createInstance(parseError, status); | |
1601 | if(TestIDNA::gPrep ==NULL){ | |
1602 | //status = U_MEMORY_ALLOCATION_ERROR; | |
1603 | return NULL; | |
1604 | } | |
1605 | } | |
1606 | return TestIDNA::gPrep; | |
1607 | ||
1608 | } | |
b75a7d8f | 1609 | #endif /* #if !UCONFIG_NO_IDNA */ |