]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/dtptngts.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-57165.0.1.tar.gz
[apple/icu.git] / icuSources / test / intltest / dtptngts.cpp
1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 2008-2016, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7 #include "unicode/utypes.h"
8
9 #if !UCONFIG_NO_FORMATTING
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include "dtptngts.h"
14
15 #include "unicode/calendar.h"
16 #include "unicode/smpdtfmt.h"
17 #include "unicode/dtfmtsym.h"
18 #include "unicode/dtptngen.h"
19 #include "cmemory.h"
20 #include "loctest.h"
21
22
23 // This is an API test, not a unit test. It doesn't test very many cases, and doesn't
24 // try to test the full functionality. It just calls each function in the class and
25 // verifies that it works on a basic level.
26
27 void IntlTestDateTimePatternGeneratorAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
28 {
29 if (exec) logln("TestSuite DateTimePatternGeneratorAPI");
30 switch (index) {
31 TESTCASE(0, testAPI);
32 TESTCASE(1, testOptions);
33 TESTCASE(2, testAllFieldPatterns);
34 TESTCASE(3, testStaticGetSkeleton);
35 TESTCASE(4, testC);
36 default: name = ""; break;
37 }
38 }
39
40 #define MAX_LOCALE 11
41
42 /**
43 * Test various generic API methods of DateTimePatternGenerator for API coverage.
44 */
45 void IntlTestDateTimePatternGeneratorAPI::testAPI(/*char *par*/)
46 {
47 UnicodeString patternData[] = {
48 UnicodeString("yM"), // 00
49 UnicodeString("yMMM"), // 01
50 UnicodeString("yMd"), // 02
51 UnicodeString("yMMMd"), // 03
52 UnicodeString("Md"), // 04
53 UnicodeString("MMMd"), // 05
54 UnicodeString("MMMMd"), // 06
55 UnicodeString("yQQQ"), // 07
56 UnicodeString("hhmm"), // 08
57 UnicodeString("HHmm"), // 09
58 UnicodeString("jjmm"), // 10
59 UnicodeString("mmss"), // 11
60 UnicodeString("yyyyMMMM"), // 12
61 UnicodeString("MMMEd"), // 13
62 UnicodeString("Ed"), // 14
63 UnicodeString("jmmssSSS"), // 15
64 UnicodeString("JJmm"), // 16
65 UnicodeString(),
66 };
67
68 const char* testLocale[MAX_LOCALE][4] = {
69 {"en", "US", "", ""}, // 0
70 {"en", "US", "", "calendar=japanese"}, // 1
71 {"de", "DE", "", ""}, // 2
72 {"fi", "", "", ""}, // 3
73 {"es", "", "", ""}, // 4
74 {"ja", "", "", ""}, // 5
75 {"ja", "", "", "calendar=japanese"}, // 6
76 {"zh", "Hans", "CN", ""}, // 7
77 {"zh", "TW", "", "calendar=roc"}, // 8
78 {"ru", "", "", ""}, // 9
79 {"zh", "", "", "calendar=chinese;numbers=hanidays"}, // 10
80 };
81
82 // For Weds, Jan 13, 1999, 23:58:59
83 UnicodeString patternResults[] = {
84 // en_US // 0 en_US
85 UnicodeString("1/1999"), // 00: yM
86 UnicodeString("Jan 1999"), // 01: yMMM
87 UnicodeString("1/13/1999"), // 02: yMd
88 UnicodeString("Jan 13, 1999"), // 03: yMMMd
89 UnicodeString("1/13"), // 04: Md
90 UnicodeString("Jan 13"), // 05: MMMd
91 UnicodeString("January 13"), // 06: MMMMd
92 UnicodeString("Q1 1999"), // 07: yQQQ
93 UnicodeString("11:58 PM"), // 08: hhmm
94 UnicodeString("23:58"), // 09: HHmm
95 UnicodeString("11:58 PM"), // 10: jjmm
96 UnicodeString("58:59"), // 11: mmss
97 UnicodeString("January 1999"), // 12: yyyyMMMM
98 UnicodeString("Wed, Jan 13"), // 13: MMMEd -> EEE, MMM d
99 UnicodeString("13 Wed"), // 14: Ed -> d EEE
100 UnicodeString("11:58:59.123 PM"), // 15: jmmssSSS -> "h:mm:ss.SSS a"
101 UnicodeString("11:58"), // 16: JJmm
102
103 // en_US@calendar=japanese // 1 en_US@calendar=japanese
104 UnicodeString("1/11 H"), // 0: yM
105 UnicodeString("Jan 11 Heisei"), // 1: yMMM
106 UnicodeString("1/13/11 H"), // 2: yMd
107 UnicodeString("Jan 13, 11 Heisei"), // 3: yMMMd
108 UnicodeString("1/13"), // 4: Md
109 UnicodeString("Jan 13"), // 5: MMMd
110 UnicodeString("January 13"), // 6: MMMMd
111 UnicodeString("Q1 11 Heisei"), // 7: yQQQ
112 UnicodeString("11:58 PM"), // 8: hhmm
113 UnicodeString("23:58"), // 9: HHmm
114 UnicodeString("11:58 PM"), // 10: jjmm
115 UnicodeString("58:59"), // 11: mmss
116 UnicodeString("January 11 Heisei"), // 12: yyyyMMMM
117 UnicodeString("Wed, Jan 13"), // 13: MMMEd -> EEE, MMM d"
118 UnicodeString("13 Wed"), // 14: Ed -> d EEE
119 UnicodeString("11:58:59.123 PM"), // 15: jmmssSSS -> "h:mm:ss.SSS a"
120 UnicodeString("11:58"), // 16: JJmm
121
122 // de_DE // 2 de_DE
123 UnicodeString("1.1999"), // 00: yM
124 UnicodeString("Jan. 1999"), // 01: yMMM
125 UnicodeString("13.1.1999"), // 02: yMd
126 UnicodeString("13. Jan. 1999"), // 03: yMMMd
127 UnicodeString("13.1."), // 04: Md
128 UnicodeString("13. Jan."), // 05: MMMd
129 UnicodeString("13. Januar"), // 06: MMMMd
130 UnicodeString("Q1 1999"), // 07: yQQQ
131 UnicodeString("11:58 PM"), // 08: hhmm
132 UnicodeString("23:58"), // 09: HHmm
133 UnicodeString("23:58"), // 10: jjmm
134 UnicodeString("58:59"), // 11: mmss
135 UnicodeString("Januar 1999"), // 12: yyyyMMMM
136 UnicodeString("Mi. 13. Jan."), // 13: MMMEd -> E d. MMM
137 UnicodeString("Mi. 13."), // 14: Ed -> E d.
138 UnicodeString("23:58:59,123"), // 15: jmmssSSS -> "HH:mm:ss,SSS"
139 UnicodeString("23:58"), // 16: JJmm
140
141 // fi // 3 fi
142 UnicodeString("1.1999"), // 00: yM (fixed expected result per ticket:6626:)
143 UnicodeString("tammi 1999"), // 01: yMMM
144 UnicodeString("13.1.1999"), // 02: yMd
145 UnicodeString("13. tammikuuta 1999"), // 03: yMMMd
146 UnicodeString("13.1."), // 04: Md
147 UnicodeString("13.1."), // 05: MMMd
148 UnicodeString("13. tammikuuta"), // 06: MMMMd
149 UnicodeString("1. nelj. 1999"), // 07: yQQQ
150 UnicodeString("11.58 ip."), // 08: hhmm
151 UnicodeString("23.58"), // 09: HHmm
152 UnicodeString("23.58"), // 10: jjmm
153 UnicodeString("58.59"), // 11: mmss
154 UnicodeString("tammikuu 1999"), // 12: yyyyMMMM
155 UnicodeString("ke 13. tammikuuta"), // 13: MMMEd -> EEE d. MMM
156 UnicodeString("ke 13."), // 14: Ed -> ccc d.
157 UnicodeString("23.58.59,123"), // 15: jmmssSSS -> "H.mm.ss,SSS"
158 UnicodeString("23.58"), // 16: JJmm
159
160 // es // 4 es
161 UnicodeString("1/1999"), // 00: yM -> "M/y"
162 UnicodeString("ene 1999"), // 01: yMMM -> "MMM y"
163 UnicodeString("13/1/1999"), // 02: yMd -> "d/M/y"
164 UnicodeString("13 ene 1999"), // 03: yMMMd -> "d MMM y"
165 UnicodeString("13/1"), // 04: Md -> "d/M"
166 UnicodeString("13 ene"), // 05: MMMd -> "d MMM"
167 UnicodeString("13 de enero"), // 06: MMMMd -> "d 'de' MMMM"
168 UnicodeString("T1 1999"), // 07: yQQQ -> "QQQ y"
169 UnicodeString("11:58 p. m."), // 08: hhmm -> "hh:mm a"
170 UnicodeString("23:58"), // 09: HHmm -> "HH:mm"
171 UnicodeString("23:58"), // 10: jjmm -> "HH:mm"
172 UnicodeString("58:59"), // 11: mmss -> "mm:ss"
173 UnicodeString("enero de 1999"), // 12: yyyyMMMM -> "MMMM 'de' yyyy"
174 CharsToUnicodeString("mi\\u00E9, 13 ene"), // 13: MMMEd -> "E d MMM"
175 CharsToUnicodeString("mi\\u00E9 13"), // 14: Ed -> "EEE d"
176 UnicodeString("23:58:59,123"), // 15: jmmssSSS -> "H:mm:ss,SSS"
177 UnicodeString("23:58"), // 16: JJmm
178
179 // ja // 5 ja
180 UnicodeString("1999/1"), // 00: yM -> y/M
181 CharsToUnicodeString("1999\\u5E741\\u6708"), // 01: yMMM -> y\u5E74M\u6708
182 UnicodeString("1999/1/13"), // 02: yMd -> y/M/d
183 CharsToUnicodeString("1999\\u5E741\\u670813\\u65E5"), // 03: yMMMd -> y\u5E74M\u6708d\u65E5
184 UnicodeString("1/13"), // 04: Md -> M/d
185 CharsToUnicodeString("1\\u670813\\u65E5"), // 05: MMMd -> M\u6708d\u65E5
186 CharsToUnicodeString("1\\u670813\\u65E5"), // 06: MMMMd -> M\u6708d\u65E5
187 CharsToUnicodeString("1999/Q1"), // 07: yQQQ -> y/QQQ
188 CharsToUnicodeString("\\u5348\\u5F8C11:58"), // 08: hhmm
189 UnicodeString("23:58"), // 09: HHmm -> HH:mm
190 UnicodeString("23:58"), // 10: jjmm
191 UnicodeString("58:59"), // 11: mmss -> mm:ss
192 CharsToUnicodeString("1999\\u5E741\\u6708"), // 12: yyyyMMMM -> y\u5E74M\u6708
193 CharsToUnicodeString("1\\u670813\\u65E5(\\u6C34)"), // 13: MMMEd -> M\u6708d\u65E5(E)
194 CharsToUnicodeString("13\\u65E5(\\u6C34)"), // 14: Ed -> d\u65E5(E)
195 UnicodeString("23:58:59.123"), // 15: jmmssSSS -> "H:mm:ss.SSS"
196 UnicodeString("23:58"), // 16: JJmm
197
198 // ja@calendar=japanese // 6 ja@calendar=japanese
199 CharsToUnicodeString("H11/1"), // 00: yM -> GGGGGy/m
200 CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u6708"), // 01: yMMM -> Gy\u5E74M\u6708
201 CharsToUnicodeString("H11/1/13"), // 02: yMd -> GGGGGy/m/d
202 CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u670813\\u65E5"), // 03: yMMMd -> Gy\u5E74M\u6708d\u65E5
203 UnicodeString("1/13"), // 04: Md -> M/d
204 CharsToUnicodeString("1\\u670813\\u65E5"), // 05: MMMd -> M\u6708d\u65E5
205 CharsToUnicodeString("1\\u670813\\u65E5"), // 06: MMMMd -> M\u6708d\u65E5
206 CharsToUnicodeString("\\u5E73\\u621011/Q1"), // 07: yQQQ -> Gy/QQQ
207 CharsToUnicodeString("\\u5348\\u5F8C11:58"), // 08: hhmm ->
208 UnicodeString("23:58"), // 09: HHmm -> HH:mm (as for ja)
209 UnicodeString("23:58"), // 10: jjmm
210 UnicodeString("58:59"), // 11: mmss -> mm:ss (as for ja)
211 CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u6708"), // 12: yyyyMMMM -> Gyyyy\u5E74M\u6708
212 CharsToUnicodeString("1\\u670813\\u65E5(\\u6C34)"), // 13: MMMEd -> M\u6708d\u65E5(E)
213 CharsToUnicodeString("13\\u65E5(\\u6C34)"), // 14: Ed -> d\u65E5(E)
214 UnicodeString("23:58:59.123"), // 15: jmmssSSS -> "H:mm:ss.SSS"
215 UnicodeString("23:58"), // 16: JJmm
216
217 // zh_Hans_CN // 7 zh_Hans_CN
218 CharsToUnicodeString("1999\\u5E741\\u6708"), // 00: yM -> y\u5E74M\u6708
219 CharsToUnicodeString("1999\\u5E741\\u6708"), // 01: yMMM -> yyyy\u5E74MMM (fixed expected result per ticket:6626:)
220 CharsToUnicodeString("1999/1/13"), // 02: yMd
221 CharsToUnicodeString("1999\\u5E741\\u670813\\u65E5"), // 03: yMMMd -> yyyy\u5E74MMMd\u65E5 (fixed expected result per ticket:6626:)
222 UnicodeString("1/13"), // 04: Md
223 CharsToUnicodeString("1\\u670813\\u65E5"), // 05: MMMd -> M\u6708d\u65E5 (fixed expected result per ticket:6626:)
224 CharsToUnicodeString("1\\u670813\\u65E5"), // 06: MMMMd -> M\u6708d\u65E5
225 CharsToUnicodeString("1999\\u5E74\\u7B2C1\\u5B63\\u5EA6"), // 07: yQQQ
226 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 08: hhmm
227 UnicodeString("23:58"), // 09: HHmm
228 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 10: jjmm
229 UnicodeString("58:59"), // 11: mmss
230 CharsToUnicodeString("1999\\u5E741\\u6708"), // 12: yyyyMMMM -> yyyy\u5E74MMM
231 CharsToUnicodeString("1\\u670813\\u65E5 \\u5468\\u4E09"), // 13: MMMEd -> MMMd\u65E5 EEE
232 CharsToUnicodeString("13 \\u5468\\u4E09"), // 14: Ed -> d\u65E5EEE
233 CharsToUnicodeString("\\u4E0B\\u534811:58:59.123"), // 15: jmmssSSS -> "ah:mm:ss.SSS"
234 UnicodeString("11:58"), // 16: JJmm
235
236 // zh_TW@calendar=roc // 8 zh_TW@calendar=roc
237 CharsToUnicodeString("\\u6C11\\u570B88/1"), // 00: yM -> Gy/M
238 CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u6708"), // 01: yMMM -> Gy\u5E74M\u6708
239 CharsToUnicodeString("\\u6C11\\u570B88/1/13"), // 02: yMd -> Gy/M/d
240 CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u670813\\u65E5"), // 03: yMMMd -> Gy\u5E74M\u6708d\u65E5
241 UnicodeString("1/13"), // 04: Md -> M/d
242 CharsToUnicodeString("1\\u670813\\u65E5"), // 05: MMMd ->M\u6708d\u65E5
243 CharsToUnicodeString("1\\u670813\\u65E5"), // 06: MMMMd ->M\u6708d\u65E5
244 CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u5B63"), // 07: yQQQ -> Gy QQQ
245 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 08: hhmm ->
246 UnicodeString("23:58"), // 09: HHmm ->
247 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 10: jjmm
248 UnicodeString("58:59"), // 11: mmss ->
249 CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u6708"), // 12: yyyyMMMM -> Gy\u5E74M\u670
250 CharsToUnicodeString("1\\u670813\\u65E5 \\u9031\\u4E09"), // 13: MMMEd -> M\u6708d\u65E5 E
251 CharsToUnicodeString("13 \\u9031\\u4E09"), // 14: Ed -> d E
252 CharsToUnicodeString("\\u4E0B\\u534811:58:59.123"), // 15: jmmssSSS -> "ah:mm:ss.SSS"
253 UnicodeString("11:58"), // 16: JJmm
254
255 // ru // 9 ru
256 UnicodeString("01.1999"), // 00: yM -> MM.y
257 CharsToUnicodeString("\\u044F\\u043D\\u0432. 1999 \\u0433."), // 01: yMMM -> LLL y
258 UnicodeString("13.01.1999"), // 02: yMd -> dd.MM.y
259 CharsToUnicodeString("13 \\u044F\\u043D\\u0432. 1999 \\u0433."), // 03: yMMMd -> d MMM y
260 UnicodeString("13.01"), // 04: Md -> dd.MM
261 CharsToUnicodeString("13 \\u044F\\u043D\\u0432."), // 05: MMMd -> d MMM
262 CharsToUnicodeString("13 \\u044F\\u043D\\u0432\\u0430\\u0440\\u044F"), // 06: MMMMd -> d MMMM
263 CharsToUnicodeString("1-\\u0439 \\u043A\\u0432. 1999 \\u0433."), // 07: yQQQ -> y QQQ
264 CharsToUnicodeString("11:58 \\u041F\\u041F"), // 08: hhmm -> hh:mm a
265 UnicodeString("23:58"), // 09: HHmm -> HH:mm
266 UnicodeString("23:58"), // 10: jjmm -> HH:mm
267 UnicodeString("58:59"), // 11: mmss -> mm:ss
268 CharsToUnicodeString("\\u044F\\u043D\\u0432\\u0430\\u0440\\u044C 1999 \\u0433."), // 12: yyyyMMMM -> LLLL y
269 CharsToUnicodeString("\\u0441\\u0440, 13 \\u044F\\u043D\\u0432."), // 13: MMMEd -> ccc, d MMM
270 CharsToUnicodeString("\\u0441\\u0440, 13"), // 14: Ed -> EEE, d
271 UnicodeString("23:58:59,123"), // 15: jmmssSSS -> "H:mm:ss,SSS"
272 UnicodeString("23:58"), // 16: JJmm
273
274 // zh@calendar=chinese,numbers=hanidays // 10 zh@calendar=chinese,numbers=hanidays
275 CharsToUnicodeString("1998\\u620A\\u5BC5\\u5E74\\u51AC\\u6708"), // 00: yMMM
276 CharsToUnicodeString("1998\\u620A\\u5BC5\\u5E74\\u51AC\\u6708"), // 01: yMMM
277 CharsToUnicodeString("1998\\u5E74\\u51AC\\u6708\\u5EFF\\u516D"), // 02: yMMMd
278 CharsToUnicodeString("1998\\u5E74\\u51AC\\u6708\\u5EFF\\u516D"), // 03: yMMMd
279 CharsToUnicodeString("11-\\u5EFF\\u516D"), // 04: Md // hmm
280 CharsToUnicodeString("\\u51AC\\u6708\\u5EFF\\u516D"), // 05: MMMd
281 CharsToUnicodeString("\\u51AC\\u6708\\u5EFF\\u516D"), // 06: MMMMd
282 CharsToUnicodeString("1998\\u620A\\u5BC5\\u5E74\\u7b2c\\u56db\\u5B63\\u5EA6"), // 07: yQQQ
283 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 08: hhmm
284 UnicodeString("23:58"), // 09: HHmm
285 CharsToUnicodeString("\\u4E0B\\u534811:58"), // 10: jjmm
286 UnicodeString("58:59"), // 11: mmss
287 CharsToUnicodeString("1998\\u620A\\u5BC5\\u5E74\\u51AC\\u6708"), // 12: yyyyMMMM
288 CharsToUnicodeString("\\u51AC\\u6708\\u5EFF\\u516D\\u5468\\u4E09"), // 13: MMMEd
289 CharsToUnicodeString("\\u5EFF\\u516D\\u5468\\u4E09"), // 14: Ed -> dE
290 CharsToUnicodeString("\\u4E0B\\u534811:58:59.123"), // 15: jmmssSS
291 UnicodeString("11:58"), // 16: JJmm
292
293 UnicodeString(),
294 };
295
296 UnicodeString patternTests2[] = {
297 UnicodeString("yyyyMMMdd"),
298 UnicodeString("yyyyqqqq"),
299 UnicodeString("yMMMdd"),
300 UnicodeString("EyyyyMMMdd"),
301 UnicodeString("yyyyMMdd"),
302 UnicodeString("yyyyMMM"),
303 UnicodeString("yyyyMM"),
304 UnicodeString("yyMM"),
305 UnicodeString("yMMMMMd"),
306 UnicodeString("EEEEEMMMMMd"),
307 UnicodeString("MMMd"),
308 UnicodeString("MMMdhmm"),
309 UnicodeString("EMMMdhmms"),
310 UnicodeString("MMdhmm"),
311 UnicodeString("EEEEMMMdhmms"),
312 UnicodeString("yyyyMMMddhhmmss"),
313 UnicodeString("EyyyyMMMddhhmmss"),
314 UnicodeString("hmm"),
315 UnicodeString("hhmm"),
316 UnicodeString("hhmmVVVV"),
317 UnicodeString(""),
318 };
319 UnicodeString patternResults2[] = {
320 UnicodeString("Oct 14, 1999"),
321 UnicodeString("4th quarter 1999"),
322 UnicodeString("Oct 14, 1999"),
323 UnicodeString("Thu, Oct 14, 1999"),
324 UnicodeString("10/14/1999"),
325 UnicodeString("Oct 1999"),
326 UnicodeString("10/1999"),
327 UnicodeString("10/99"),
328 UnicodeString("O 14, 1999"),
329 UnicodeString("T, O 14"),
330 UnicodeString("Oct 14"),
331 UnicodeString("Oct 14, 6:58 AM"),
332 UnicodeString("Thu, Oct 14, 6:58:59 AM"),
333 UnicodeString("10/14, 6:58 AM"),
334 UnicodeString("Thursday, Oct 14, 6:58:59 AM"),
335 UnicodeString("Oct 14, 1999, 6:58:59 AM"),
336 UnicodeString("Thu, Oct 14, 1999, 6:58:59 AM"),
337 UnicodeString("6:58 AM"),
338 UnicodeString("6:58 AM"),
339 UnicodeString("6:58 AM GMT"),
340 UnicodeString(""),
341 };
342
343 // results for getSkeletons() and getPatternForSkeleton()
344 const UnicodeString testSkeletonsResults[] = {
345 UnicodeString("HH:mm"),
346 UnicodeString("MMMMd"),
347 UnicodeString("MMMMMdd"),
348 };
349
350 const UnicodeString testBaseSkeletonsResults[] = {
351 UnicodeString("Hm"),
352 UnicodeString("MMMMd"),
353 UnicodeString("MMMMMd"),
354 };
355
356 UnicodeString newDecimal(" "); // space
357 UnicodeString newAppendItemName("hrs.");
358 UnicodeString newAppendItemFormat("{1} {0}");
359 UnicodeString newDateTimeFormat("{1} {0}");
360 UErrorCode status = U_ZERO_ERROR;
361 UnicodeString conflictingPattern;
362 UDateTimePatternConflict conflictingStatus = UDATPG_NO_CONFLICT;
363 (void)conflictingStatus; // Suppress set but not used warning.
364
365 // ======= Test CreateInstance with default locale
366 logln("Testing DateTimePatternGenerator createInstance from default locale");
367
368 DateTimePatternGenerator *instFromDefaultLocale=DateTimePatternGenerator::createInstance(status);
369 if (U_FAILURE(status)) {
370 dataerrln("ERROR: Could not create DateTimePatternGenerator (default) - exitting");
371 return;
372 }
373 else {
374 delete instFromDefaultLocale;
375 }
376
377 // ======= Test CreateInstance with given locale
378 logln("Testing DateTimePatternGenerator createInstance from French locale");
379 status = U_ZERO_ERROR;
380 DateTimePatternGenerator *instFromLocale=DateTimePatternGenerator::createInstance(Locale::getFrench(), status);
381 if (U_FAILURE(status)) {
382 dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getFrench()) - exitting");
383 return;
384 }
385
386 // ======= Test clone DateTimePatternGenerator
387 logln("Testing DateTimePatternGenerator::clone()");
388 status = U_ZERO_ERROR;
389
390
391 UnicodeString decimalSymbol = instFromLocale->getDecimal();
392 UnicodeString newDecimalSymbol = UnicodeString("*");
393 decimalSymbol = instFromLocale->getDecimal();
394 instFromLocale->setDecimal(newDecimalSymbol);
395 DateTimePatternGenerator *cloneDTPatternGen=instFromLocale->clone();
396 decimalSymbol = cloneDTPatternGen->getDecimal();
397 if (decimalSymbol != newDecimalSymbol) {
398 errln("ERROR: inconsistency is found in cloned object.");
399 }
400 if ( !(*cloneDTPatternGen == *instFromLocale) ) {
401 errln("ERROR: inconsistency is found in cloned object.");
402 }
403
404 if ( *cloneDTPatternGen != *instFromLocale ) {
405 errln("ERROR: inconsistency is found in cloned object.");
406 }
407
408 delete instFromLocale;
409 delete cloneDTPatternGen;
410
411 // ======= Test simple use cases
412 logln("Testing simple use cases");
413 status = U_ZERO_ERROR;
414 Locale deLocale=Locale::getGermany();
415 UDate sampleDate=LocaleTest::date(99, 9, 13, 23, 58, 59);
416 DateTimePatternGenerator *gen = DateTimePatternGenerator::createInstance(deLocale, status);
417 if (U_FAILURE(status)) {
418 dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getGermany()) - exitting");
419 return;
420 }
421 UnicodeString findPattern = gen->getBestPattern(UnicodeString("MMMddHmm"), status);
422 SimpleDateFormat *format = new SimpleDateFormat(findPattern, deLocale, status);
423 if (U_FAILURE(status)) {
424 dataerrln("ERROR: Could not create SimpleDateFormat (Locale::getGermany())");
425 delete gen;
426 return;
427 }
428 TimeZone *zone = TimeZone::createTimeZone(UnicodeString("ECT"));
429 if (zone==NULL) {
430 dataerrln("ERROR: Could not create TimeZone ECT");
431 delete gen;
432 delete format;
433 return;
434 }
435 format->setTimeZone(*zone);
436 UnicodeString dateReturned, expectedResult;
437 dateReturned.remove();
438 dateReturned = format->format(sampleDate, dateReturned, status);
439 expectedResult=UnicodeString("14. Okt., 08:58", -1, US_INV);
440 if ( dateReturned != expectedResult ) {
441 errln("ERROR: Simple test in getBestPattern with Locale::getGermany()).");
442 }
443 // add new pattern
444 status = U_ZERO_ERROR;
445 conflictingStatus = gen->addPattern(UnicodeString("d'. von' MMMM", -1, US_INV), true, conflictingPattern, status);
446 if (U_FAILURE(status)) {
447 errln("ERROR: Could not addPattern - d\'. von\' MMMM");
448 }
449 status = U_ZERO_ERROR;
450 UnicodeString testPattern=gen->getBestPattern(UnicodeString("MMMMdd"), status);
451 testPattern=gen->getBestPattern(UnicodeString("MMMddHmm"), status);
452 format->applyPattern(gen->getBestPattern(UnicodeString("MMMMdHmm"), status));
453 dateReturned.remove();
454 dateReturned = format->format(sampleDate, dateReturned, status);
455 expectedResult=UnicodeString("14. von Oktober, 08:58", -1, US_INV);
456 if ( dateReturned != expectedResult ) {
457 errln(UnicodeString("ERROR: Simple test addPattern failed!: d\'. von\' MMMM Got: ") + dateReturned + UnicodeString(" Expected: ") + expectedResult);
458 }
459 delete format;
460
461 // get a pattern and modify it
462 format = (SimpleDateFormat *)DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull,
463 deLocale);
464 format->setTimeZone(*zone);
465 UnicodeString pattern;
466 pattern = format->toPattern(pattern);
467 dateReturned.remove();
468 dateReturned = format->format(sampleDate, dateReturned, status);
469 expectedResult=CharsToUnicodeString("Donnerstag, 14. Oktober 1999 um 08:58:59 Mitteleurop\\u00E4ische Sommerzeit");
470 if ( dateReturned != expectedResult ) {
471 errln("ERROR: Simple test uses full date format.");
472 errln(UnicodeString(" Got: ") + dateReturned + UnicodeString(" Expected: ") + expectedResult);
473 }
474
475 // modify it to change the zone.
476 UnicodeString newPattern = gen->replaceFieldTypes(pattern, UnicodeString("vvvv"), status);
477 format->applyPattern(newPattern);
478 dateReturned.remove();
479 dateReturned = format->format(sampleDate, dateReturned, status);
480 expectedResult=CharsToUnicodeString("Donnerstag, 14. Oktober 1999 um 08:58:59 Mitteleurop\\u00E4ische Zeit");
481 if ( dateReturned != expectedResult ) {
482 errln("ERROR: Simple test modify the timezone!");
483 errln(UnicodeString(" Got: ")+ dateReturned + UnicodeString(" Expected: ") + expectedResult);
484 }
485
486 // setDeciaml(), getDeciaml()
487 gen->setDecimal(newDecimal);
488 if (newDecimal != gen->getDecimal()) {
489 errln("ERROR: unexpected result from setDecimal() and getDecimal()!.\n");
490 }
491
492 // setAppenItemName() , getAppendItemName()
493 gen->setAppendItemName(UDATPG_HOUR_FIELD, newAppendItemName);
494 if (newAppendItemName != gen->getAppendItemName(UDATPG_HOUR_FIELD)) {
495 errln("ERROR: unexpected result from setAppendItemName() and getAppendItemName()!.\n");
496 }
497
498 // setAppenItemFormat() , getAppendItemFormat()
499 gen->setAppendItemFormat(UDATPG_HOUR_FIELD, newAppendItemFormat);
500 if (newAppendItemFormat != gen->getAppendItemFormat(UDATPG_HOUR_FIELD)) {
501 errln("ERROR: unexpected result from setAppendItemFormat() and getAppendItemFormat()!.\n");
502 }
503
504 // setDateTimeFormat() , getDateTimeFormat()
505 gen->setDateTimeFormat(newDateTimeFormat);
506 if (newDateTimeFormat != gen->getDateTimeFormat()) {
507 errln("ERROR: unexpected result from setDateTimeFormat() and getDateTimeFormat()!.\n");
508 }
509
510 // ======== Test getSkeleton and getBaseSkeleton
511 status = U_ZERO_ERROR;
512 pattern = UnicodeString("dd-MMM");
513 UnicodeString expectedSkeleton = UnicodeString("MMMdd");
514 UnicodeString expectedBaseSkeleton = UnicodeString("MMMd");
515 UnicodeString retSkeleton = gen->getSkeleton(pattern, status);
516 if(U_FAILURE(status) || retSkeleton != expectedSkeleton ) {
517 errln("ERROR: Unexpected result from getSkeleton().\n");
518 errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected: ") + expectedSkeleton );
519 }
520 retSkeleton = gen->getBaseSkeleton(pattern, status);
521 if(U_FAILURE(status) || retSkeleton != expectedBaseSkeleton) {
522 errln("ERROR: Unexpected result from getBaseSkeleton().\n");
523 errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected:")+ expectedBaseSkeleton);
524 }
525
526 pattern = UnicodeString("dd/MMMM/yy");
527 expectedSkeleton = UnicodeString("yyMMMMdd");
528 expectedBaseSkeleton = UnicodeString("yMMMMd");
529 retSkeleton = gen->getSkeleton(pattern, status);
530 if(U_FAILURE(status) || retSkeleton != expectedSkeleton ) {
531 errln("ERROR: Unexpected result from getSkeleton().\n");
532 errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected: ") + expectedSkeleton );
533 }
534 retSkeleton = gen->getBaseSkeleton(pattern, status);
535 if(U_FAILURE(status) || retSkeleton != expectedBaseSkeleton) {
536 errln("ERROR: Unexpected result from getBaseSkeleton().\n");
537 errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected:")+ expectedBaseSkeleton);
538 }
539 delete format;
540 delete zone;
541 delete gen;
542
543 {
544 // Trac# 6104
545 status = U_ZERO_ERROR;
546 pattern = UnicodeString("YYYYMMM");
547 UnicodeString expR = CharsToUnicodeString("1999\\u5E741\\u6708"); // fixed expected result per ticket:6626:
548 Locale loc("ja");
549 UDate testDate1= LocaleTest::date(99, 0, 13, 23, 58, 59);
550 DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
551 if(U_FAILURE(status)) {
552 dataerrln("ERROR: Could not create DateTimePatternGenerator");
553 return;
554 }
555 UnicodeString bPattern = patGen->getBestPattern(pattern, status);
556 UnicodeString rDate;
557 SimpleDateFormat sdf(bPattern, loc, status);
558 rDate.remove();
559 rDate = sdf.format(testDate1, rDate);
560
561 logln(UnicodeString(" ja locale with skeleton: YYYYMMM Best Pattern:") + bPattern);
562 logln(UnicodeString(" Formatted date:") + rDate);
563
564 if ( expR!= rDate ) {
565 errln(UnicodeString("\nERROR: Test Japanese month hack Got: ") + rDate +
566 UnicodeString(" Expected: ") + expR );
567 }
568
569 delete patGen;
570 }
571 { // Trac# 6104
572 Locale loc("zh");
573 UnicodeString expR = CharsToUnicodeString("1999\\u5E741\\u6708"); // fixed expected result per ticket:6626:
574 UDate testDate1= LocaleTest::date(99, 0, 13, 23, 58, 59);
575 DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
576 if(U_FAILURE(status)) {
577 dataerrln("ERROR: Could not create DateTimePatternGenerator");
578 return;
579 }
580 UnicodeString bPattern = patGen->getBestPattern(pattern, status);
581 UnicodeString rDate;
582 SimpleDateFormat sdf(bPattern, loc, status);
583 rDate.remove();
584 rDate = sdf.format(testDate1, rDate);
585
586 logln(UnicodeString(" zh locale with skeleton: YYYYMMM Best Pattern:") + bPattern);
587 logln(UnicodeString(" Formatted date:") + rDate);
588 if ( expR!= rDate ) {
589 errln(UnicodeString("\nERROR: Test Chinese month hack Got: ") + rDate +
590 UnicodeString(" Expected: ") + expR );
591 }
592 delete patGen;
593 }
594
595 {
596 // Trac# 6172 duplicate time pattern
597 status = U_ZERO_ERROR;
598 pattern = UnicodeString("hmv");
599 UnicodeString expR = UnicodeString("h:mm a v"); // avail formats has hm -> "h:mm a" (fixed expected result per ticket:6626:)
600 Locale loc("en");
601 DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
602 if(U_FAILURE(status)) {
603 dataerrln("ERROR: Could not create DateTimePatternGenerator");
604 return;
605 }
606 UnicodeString bPattern = patGen->getBestPattern(pattern, status);
607 logln(UnicodeString(" en locale with skeleton: hmv Best Pattern:") + bPattern);
608
609 if ( expR!= bPattern ) {
610 errln(UnicodeString("\nERROR: Test EN time format Got: ") + bPattern +
611 UnicodeString(" Expected: ") + expR );
612 }
613
614 delete patGen;
615 }
616
617
618 // ======= Test various skeletons.
619 logln("Testing DateTimePatternGenerator with various skeleton");
620
621 status = U_ZERO_ERROR;
622 int32_t localeIndex=0;
623 int32_t resultIndex=0;
624 UnicodeString resultDate;
625 UDate testDate= LocaleTest::date(99, 0, 13, 23, 58, 59) + 123.0;
626 while (localeIndex < MAX_LOCALE )
627 {
628 int32_t dataIndex=0;
629 UnicodeString bestPattern;
630
631 Locale loc(testLocale[localeIndex][0], testLocale[localeIndex][1], testLocale[localeIndex][2], testLocale[localeIndex][3]);
632 logln("\n\n Locale: %s_%s_%s@%s", testLocale[localeIndex][0], testLocale[localeIndex][1], testLocale[localeIndex][2], testLocale[localeIndex][3]);
633 DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
634 if(U_FAILURE(status)) {
635 dataerrln("ERROR: Could not create DateTimePatternGenerator with locale index:%d . - exitting\n", localeIndex);
636 return;
637 }
638 while (patternData[dataIndex].length() > 0) {
639 log(patternData[dataIndex]);
640 bestPattern = patGen->getBestPattern(patternData[dataIndex++], status);
641 logln(UnicodeString(" -> ") + bestPattern);
642
643 SimpleDateFormat sdf(bestPattern, loc, status);
644 resultDate.remove();
645 resultDate = sdf.format(testDate, resultDate);
646 if ( resultDate != patternResults[resultIndex] ) {
647 errln(UnicodeString("\nERROR: Test various skeletons[") + (dataIndex-1) + UnicodeString("], localeIndex ") + localeIndex +
648 UnicodeString(". Got: \"") + resultDate + UnicodeString("\" Expected: \"") + patternResults[resultIndex] + "\"" );
649 }
650
651 resultIndex++;
652 }
653 delete patGen;
654 localeIndex++;
655 }
656
657 // ======= More tests ticket#6110
658 logln("Testing DateTimePatternGenerator with various skeleton");
659
660 status = U_ZERO_ERROR;
661 localeIndex=0;
662 resultIndex=0;
663 testDate= LocaleTest::date(99, 9, 13, 23, 58, 59);
664 {
665 int32_t dataIndex=0;
666 UnicodeString bestPattern;
667 logln("\n\n Test various skeletons for English locale...");
668 DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(Locale::getEnglish(), status);
669 if(U_FAILURE(status)) {
670 dataerrln("ERROR: Could not create DateTimePatternGenerator with locale English . - exitting\n");
671 return;
672 }
673 TimeZone *enZone = TimeZone::createTimeZone(UnicodeString("ECT/GMT"));
674 if (enZone==NULL) {
675 dataerrln("ERROR: Could not create TimeZone ECT");
676 delete patGen;
677 return;
678 }
679 SimpleDateFormat *enFormat = (SimpleDateFormat *)DateFormat::createDateTimeInstance(DateFormat::kFull,
680 DateFormat::kFull, Locale::getEnglish());
681 enFormat->setTimeZone(*enZone);
682 while (patternTests2[dataIndex].length() > 0) {
683 logln(patternTests2[dataIndex]);
684 bestPattern = patGen->getBestPattern(patternTests2[dataIndex], status);
685 logln(UnicodeString(" -> ") + bestPattern);
686 enFormat->applyPattern(bestPattern);
687 resultDate.remove();
688 resultDate = enFormat->format(testDate, resultDate);
689 if ( resultDate != patternResults2[resultIndex] ) {
690 errln(UnicodeString("\nERROR: Test various skeletons[") + dataIndex
691 + UnicodeString("]. Got: ") + resultDate + UnicodeString(" Expected: ") +
692 patternResults2[resultIndex] );
693 }
694 dataIndex++;
695 resultIndex++;
696 }
697 delete patGen;
698 delete enZone;
699 delete enFormat;
700 }
701
702
703
704 // ======= Test random skeleton
705 DateTimePatternGenerator *randDTGen= DateTimePatternGenerator::createInstance(status);
706 if (U_FAILURE(status)) {
707 dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getFrench()) - exitting");
708 return;
709 }
710 UChar newChar;
711 int32_t i;
712 for (i=0; i<10; ++i) {
713 UnicodeString randomSkeleton;
714 int32_t len = rand() % 20;
715 for (int32_t j=0; j<len; ++j ) {
716 while ((newChar = (UChar)(rand()%0x7f))>=(UChar)0x20) {
717 randomSkeleton += newChar;
718 }
719 }
720 UnicodeString bestPattern = randDTGen->getBestPattern(randomSkeleton, status);
721 }
722 delete randDTGen;
723
724 // UnicodeString randomString=Unicode
725 // ======= Test getStaticClassID()
726
727 logln("Testing getStaticClassID()");
728 status = U_ZERO_ERROR;
729 DateTimePatternGenerator *test= DateTimePatternGenerator::createInstance(status);
730
731 if(test->getDynamicClassID() != DateTimePatternGenerator::getStaticClassID()) {
732 errln("ERROR: getDynamicClassID() didn't return the expected value");
733 }
734 delete test;
735
736 // ====== Test createEmptyInstance()
737
738 logln("Testing createEmptyInstance()");
739 status = U_ZERO_ERROR;
740
741 test = DateTimePatternGenerator::createEmptyInstance(status);
742 if(U_FAILURE(status)) {
743 errln("ERROR: Fail to create an empty instance ! - exitting.\n");
744 delete test;
745 return;
746 }
747
748 conflictingStatus = test->addPattern(UnicodeString("MMMMd"), true, conflictingPattern, status);
749 status = U_ZERO_ERROR;
750 testPattern=test->getBestPattern(UnicodeString("MMMMdd"), status);
751 conflictingStatus = test->addPattern(UnicodeString("HH:mm"), true, conflictingPattern, status);
752 conflictingStatus = test->addPattern(UnicodeString("MMMMMdd"), true, conflictingPattern, status); //duplicate pattern
753 StringEnumeration *output=NULL;
754 output = test->getRedundants(status);
755 expectedResult=UnicodeString("MMMMd");
756 if (output != NULL) {
757 output->reset(status);
758 const UnicodeString *dupPattern=output->snext(status);
759 if ( (dupPattern==NULL) || (*dupPattern != expectedResult) ) {
760 errln("ERROR: Fail in getRedundants !\n");
761 }
762 }
763
764 // ======== Test getSkeletons and getBaseSkeletons
765 StringEnumeration* ptrSkeletonEnum = test->getSkeletons(status);
766 if(U_FAILURE(status)) {
767 errln("ERROR: Fail to get skeletons !\n");
768 }
769 UnicodeString returnPattern, *ptrSkeleton;
770 ptrSkeletonEnum->reset(status);
771 int32_t count=ptrSkeletonEnum->count(status);
772 for (i=0; i<count; ++i) {
773 ptrSkeleton = (UnicodeString *)ptrSkeletonEnum->snext(status);
774 returnPattern = test->getPatternForSkeleton(*ptrSkeleton);
775 if ( returnPattern != testSkeletonsResults[i] ) {
776 errln(UnicodeString("ERROR: Unexpected result from getSkeletons and getPatternForSkeleton\nGot: ") + returnPattern
777 + UnicodeString("\nExpected: ") + testSkeletonsResults[i]
778 + UnicodeString("\n"));
779 }
780 }
781 StringEnumeration* ptrBaseSkeletonEnum = test->getBaseSkeletons(status);
782 if(U_FAILURE(status)) {
783 errln("ERROR: Fail to get base skeletons !\n");
784 }
785 count=ptrBaseSkeletonEnum->count(status);
786 for (i=0; i<count; ++i) {
787 ptrSkeleton = (UnicodeString *)ptrBaseSkeletonEnum->snext(status);
788 if ( *ptrSkeleton != testBaseSkeletonsResults[i] ) {
789 errln("ERROR: Unexpected result from getBaseSkeletons() !\n");
790 }
791 }
792
793 // ========= DateTimePatternGenerator sample code in Userguide
794 // set up the generator
795 Locale locale = Locale::getFrench();
796 status = U_ZERO_ERROR;
797 DateTimePatternGenerator *generator = DateTimePatternGenerator::createInstance( locale, status);
798
799 // get a pattern for an abbreviated month and day
800 pattern = generator->getBestPattern(UnicodeString("MMMd"), status);
801 SimpleDateFormat formatter(pattern, locale, status);
802
803 zone = TimeZone::createTimeZone(UnicodeString("GMT"));
804 formatter.setTimeZone(*zone);
805 // use it to format (or parse)
806 UnicodeString formatted;
807 formatted = formatter.format(Calendar::getNow(), formatted, status);
808 // for French, the result is "13 sept."
809 formatted.remove();
810 // cannot use the result from getNow() because the value change evreyday.
811 testDate= LocaleTest::date(99, 0, 13, 23, 58, 59);
812 formatted = formatter.format(testDate, formatted, status);
813 expectedResult=UnicodeString("14 janv.");
814 if ( formatted != expectedResult ) {
815 errln("ERROR: Userguide sample code result!");
816 errln(UnicodeString(" Got: ")+ formatted + UnicodeString(" Expected: ") + expectedResult);
817 }
818
819 delete zone;
820 delete output;
821 delete ptrSkeletonEnum;
822 delete ptrBaseSkeletonEnum;
823 delete test;
824 delete generator;
825 }
826
827 /**
828 * Test handling of options
829 *
830 * For reference, as of ICU 4.3.3,
831 * root/gregorian has
832 * Hm{"H:mm"}
833 * Hms{"H:mm:ss"}
834 * hm{"h:mm a"}
835 * hms{"h:mm:ss a"}
836 * en/gregorian has
837 * Hm{"H:mm"}
838 * Hms{"H:mm:ss"}
839 * hm{"h:mm a"}
840 * be/gregorian has
841 * HHmmss{"HH.mm.ss"}
842 * Hm{"HH.mm"}
843 * hm{"h.mm a"}
844 * hms{"h.mm.ss a"}
845 */
846 typedef struct DTPtnGenOptionsData {
847 const char *locale;
848 const char *skel;
849 const char *expectedPattern;
850 UDateTimePatternMatchOptions options;
851 } DTPtnGenOptionsData;
852 void IntlTestDateTimePatternGeneratorAPI::testOptions(/*char *par*/)
853 {
854 DTPtnGenOptionsData testData[] = {
855 // locale skel expectedPattern options
856 { "en", "Hmm", "HH:mm", UDATPG_MATCH_NO_OPTIONS },
857 { "en", "HHmm", "HH:mm", UDATPG_MATCH_NO_OPTIONS },
858 { "en", "hhmm", "h:mm a", UDATPG_MATCH_NO_OPTIONS },
859 { "en", "Hmm", "HH:mm", UDATPG_MATCH_HOUR_FIELD_LENGTH },
860 { "en", "HHmm", "HH:mm", UDATPG_MATCH_HOUR_FIELD_LENGTH },
861 { "en", "hhmm", "hh:mm a", UDATPG_MATCH_HOUR_FIELD_LENGTH },
862 { "da", "Hmm", "HH.mm", UDATPG_MATCH_NO_OPTIONS },
863 { "da", "HHmm", "HH.mm", UDATPG_MATCH_NO_OPTIONS },
864 { "da", "hhmm", "h.mm a", UDATPG_MATCH_NO_OPTIONS },
865 { "da", "Hmm", "H.mm", UDATPG_MATCH_HOUR_FIELD_LENGTH },
866 { "da", "HHmm", "HH.mm", UDATPG_MATCH_HOUR_FIELD_LENGTH },
867 { "da", "hhmm", "hh.mm a", UDATPG_MATCH_HOUR_FIELD_LENGTH },
868 //
869 { "en", "yyyy", "yyyy", UDATPG_MATCH_NO_OPTIONS },
870 { "en", "YYYY", "YYYY", UDATPG_MATCH_NO_OPTIONS },
871 { "en", "U", "y", UDATPG_MATCH_NO_OPTIONS },
872 { "en@calendar=japanese", "yyyy", "y G", UDATPG_MATCH_NO_OPTIONS },
873 { "en@calendar=japanese", "YYYY", "Y G", UDATPG_MATCH_NO_OPTIONS },
874 { "en@calendar=japanese", "U", "y G", UDATPG_MATCH_NO_OPTIONS },
875 { "en@calendar=chinese", "yyyy", "r(U)", UDATPG_MATCH_NO_OPTIONS },
876 { "en@calendar=chinese", "YYYY", "Y(Y)", UDATPG_MATCH_NO_OPTIONS }, // not a good result, want r(Y) or r(U)
877 { "en@calendar=chinese", "U", "r(U)", UDATPG_MATCH_NO_OPTIONS },
878 { "en@calendar=chinese", "Gy", "r(U)", UDATPG_MATCH_NO_OPTIONS },
879 { "en@calendar=chinese", "GU", "r(U)", UDATPG_MATCH_NO_OPTIONS },
880 { "en@calendar=chinese", "ULLL", "MMM U", UDATPG_MATCH_NO_OPTIONS },
881 { "en@calendar=chinese", "yMMM", "MMM r(U)", UDATPG_MATCH_NO_OPTIONS },
882 { "en@calendar=chinese", "GUMMM", "MMM r(U)", UDATPG_MATCH_NO_OPTIONS },
883 { "zh@calendar=chinese", "yyyy", "U\\u5E74", UDATPG_MATCH_NO_OPTIONS },
884 { "zh@calendar=chinese", "YYYY", "Y\\u5E74", UDATPG_MATCH_NO_OPTIONS }, // not a great result, may want r(Y) or r(U)
885 { "zh@calendar=chinese", "U", "U\\u5E74", UDATPG_MATCH_NO_OPTIONS },
886 { "zh@calendar=chinese", "Gy", "rU\\u5E74", UDATPG_MATCH_NO_OPTIONS },
887 { "zh@calendar=chinese", "GU", "rU\\u5E74", UDATPG_MATCH_NO_OPTIONS },
888 { "zh@calendar=chinese", "ULLL", "U\\u5E74MMM", UDATPG_MATCH_NO_OPTIONS },
889 { "zh@calendar=chinese", "yMMM", "rU\\u5E74MMM", UDATPG_MATCH_NO_OPTIONS },
890 { "zh@calendar=chinese", "GUMMM", "rU\\u5E74MMM", UDATPG_MATCH_NO_OPTIONS },
891 };
892
893 int count = UPRV_LENGTHOF(testData);
894 const DTPtnGenOptionsData * testDataPtr = testData;
895
896 for (; count-- > 0; ++testDataPtr) {
897 UErrorCode status = U_ZERO_ERROR;
898
899 Locale locale(testDataPtr->locale);
900 UnicodeString skel(testDataPtr->skel);
901 UnicodeString expectedPattern(UnicodeString(testDataPtr->expectedPattern).unescape());
902 UDateTimePatternMatchOptions options = testDataPtr->options;
903
904 DateTimePatternGenerator * dtpgen = DateTimePatternGenerator::createInstance(locale, status);
905 if (U_FAILURE(status)) {
906 dataerrln("Unable to create DateTimePatternGenerator instance for locale(%s): %s", locale.getName(), u_errorName(status));
907 delete dtpgen;
908 continue;
909 }
910 UnicodeString pattern = dtpgen->getBestPattern(skel, options, status);
911 if (pattern.compare(expectedPattern) != 0) {
912 errln( UnicodeString("ERROR in getBestPattern, locale ") + UnicodeString(testDataPtr->locale) +
913 UnicodeString(", skeleton ") + skel +
914 ((options)?UnicodeString(", options!=0"):UnicodeString(", options==0")) +
915 UnicodeString(", expected pattern ") + expectedPattern +
916 UnicodeString(", got ") + pattern );
917 }
918 delete dtpgen;
919 }
920 }
921
922 /**
923 * Test that DTPG can handle all valid pattern character / length combinations
924 *
925 */
926 #define FIELD_LENGTHS_COUNT 6
927 #define FIELD_LENGTH_MAX 8
928 #define MUST_INCLUDE_COUNT 5
929
930 typedef struct AllFieldsTestItem {
931 char patternChar;
932 int8_t fieldLengths[FIELD_LENGTHS_COUNT+1]; // up to FIELD_LENGTHS_COUNT lengths to try
933 // (length <=FIELD_LENGTH_MAX) plus 0 terminator
934 char mustIncludeOneOf[MUST_INCLUDE_COUNT+1];// resulting pattern must include at least one of
935 // these as a pattern char (0-terminated list)
936 } AllFieldsTestItem;
937
938 void IntlTestDateTimePatternGeneratorAPI::testAllFieldPatterns(/*char *par*/)
939 {
940 const char * localeNames[] = {
941 "root",
942 "root@calendar=japanese",
943 "root@calendar=chinese",
944 "en",
945 "en@calendar=japanese",
946 "en@calendar=chinese",
947 NULL // terminator
948 };
949 AllFieldsTestItem testData[] = {
950 //pat fieldLengths generated pattern must
951 //chr to test include one of these
952 { 'G', {1,2,3,4,5,0}, "G" }, // era
953 // year
954 { 'y', {1,2,3,4,0}, "yU" }, // year
955 { 'Y', {1,2,3,4,0}, "Y" }, // year for week of year
956 { 'u', {1,2,3,4,5,0}, "yuU" }, // extended year
957 { 'U', {1,2,3,4,5,0}, "yU" }, // cyclic year name
958 // quarter
959 { 'Q', {1,2,3,4,0}, "Qq" }, // x
960 { 'q', {1,2,3,4,0}, "Qq" }, // standalone
961 // month
962 { 'M', {1,2,3,4,5,0}, "ML" }, // x
963 { 'L', {1,2,3,4,5,0}, "ML" }, // standalone
964 // week
965 { 'w', {1,2,0}, "w" }, // week of year
966 { 'W', {1,0}, "W" }, // week of month
967 // day
968 { 'd', {1,2,0}, "d" }, // day of month
969 { 'D', {1,2,3,0}, "D" }, // day of year
970 { 'F', {1,0}, "F" }, // day of week in month
971 { 'g', {7,0}, "g" }, // modified julian day
972 // weekday
973 { 'E', {1,2,3,4,5,6}, "Eec" }, // day of week
974 { 'e', {1,2,3,4,5,6}, "Eec" }, // local day of week
975 { 'c', {1,2,3,4,5,6}, "Eec" }, // standalone local day of week
976 // day period
977 // { 'a', {1,0}, "a" }, // am or pm // not clear this one is supposed to work (it doesn't)
978 // hour
979 { 'h', {1,2,0}, "hK" }, // 12 (1-12)
980 { 'H', {1,2,0}, "Hk" }, // 24 (0-23)
981 { 'K', {1,2,0}, "hK" }, // 12 (0-11)
982 { 'k', {1,2,0}, "Hk" }, // 24 (1-24)
983 { 'j', {1,2,0}, "hHKk" }, // locale default
984 // minute
985 { 'm', {1,2,0}, "m" }, // x
986 // second & fractions
987 { 's', {1,2,0}, "s" }, // x
988 { 'S', {1,2,3,4,0}, "S" }, // fractional second
989 { 'A', {8,0}, "A" }, // milliseconds in day
990 // zone
991 { 'z', {1,2,3,4,0}, "z" }, // x
992 { 'Z', {1,2,3,4,5,0}, "Z" }, // x
993 { 'O', {1,4,0}, "O" }, // x
994 { 'v', {1,4,0}, "v" }, // x
995 { 'V', {1,2,3,4,0}, "V" }, // x
996 { 'X', {1,2,3,4,5,0}, "X" }, // x
997 { 'x', {1,2,3,4,5,0}, "x" }, // x
998 };
999
1000 const char ** localeNamesPtr = localeNames;
1001 const char * localeName;
1002 while ( (localeName = *localeNamesPtr++) != NULL) {
1003 UErrorCode status = U_ZERO_ERROR;
1004 Locale locale = Locale::createFromName(localeName);
1005 DateTimePatternGenerator * dtpg = DateTimePatternGenerator::createInstance(locale, status);
1006 if (U_SUCCESS(status)) {
1007 const AllFieldsTestItem * testDataPtr = testData;
1008 int itemCount = UPRV_LENGTHOF(testData);
1009 for (; itemCount-- > 0; ++testDataPtr) {
1010 char skelBuf[FIELD_LENGTH_MAX];
1011 int32_t chrIndx, lenIndx;
1012 for (chrIndx = 0; chrIndx < FIELD_LENGTH_MAX; chrIndx++) {
1013 skelBuf[chrIndx] = testDataPtr->patternChar;
1014 }
1015 for (lenIndx = 0; lenIndx < FIELD_LENGTHS_COUNT; lenIndx++) {
1016 int32_t skelLen = testDataPtr->fieldLengths[lenIndx];
1017 if (skelLen <= 0) {
1018 break;
1019 }
1020 if (skelLen > FIELD_LENGTH_MAX) {
1021 continue;
1022 }
1023 UnicodeString skeleton(skelBuf, skelLen, US_INV);
1024 UnicodeString pattern = dtpg->getBestPattern(skeleton, status);
1025 if (U_FAILURE(status)) {
1026 errln("DateTimePatternGenerator getBestPattern for locale %s, skelChar %c skelLength %d fails: %s",
1027 locale.getName(), testDataPtr->patternChar, skelLen, u_errorName(status));
1028 } else if (pattern.length() <= 0) {
1029 errln("DateTimePatternGenerator getBestPattern for locale %s, skelChar %c skelLength %d produces 0-length pattern",
1030 locale.getName(), testDataPtr->patternChar, skelLen);
1031 } else {
1032 // test that resulting pattern has at least one char in mustIncludeOneOf
1033 UnicodeString mustIncludeOneOf(testDataPtr->mustIncludeOneOf, -1, US_INV);
1034 int32_t patIndx, patLen = pattern.length();
1035 UBool inQuoted = FALSE;
1036 for (patIndx = 0; patIndx < patLen; patIndx++) {
1037 UChar c = pattern.charAt(patIndx);
1038 if (c == 0x27) {
1039 inQuoted = !inQuoted;
1040 } else if (!inQuoted && c <= 0x007A && c >= 0x0041) {
1041 if (mustIncludeOneOf.indexOf(c) >= 0) {
1042 break;
1043 }
1044 }
1045 }
1046 if (patIndx >= patLen) {
1047 errln(UnicodeString("DateTimePatternGenerator getBestPattern for locale ") +
1048 UnicodeString(locale.getName(),-1,US_INV) +
1049 ", skeleton " + skeleton +
1050 ", produces pattern without required chars: " + pattern);
1051 }
1052
1053 }
1054 }
1055 }
1056 delete dtpg;
1057 } else {
1058 dataerrln("Create DateTimePatternGenerator instance for locale(%s) fails: %s",
1059 locale.getName(), u_errorName(status));
1060 }
1061 }
1062 }
1063
1064 void IntlTestDateTimePatternGeneratorAPI::testStaticGetSkeleton(/*char *par*/)
1065 {
1066 // Verify that staticGetSkeleton() doesn't mangle skeletons. (Ticket #11985)
1067 static const char* const testData[] = {
1068 "jmm",
1069 "jjmm",
1070 "Jmm",
1071 "JJmm"
1072 };
1073
1074 for (size_t i = 0; i < UPRV_LENGTHOF(testData); i++) {
1075 UErrorCode status = U_ZERO_ERROR;
1076 UnicodeString skeleton = DateTimePatternGenerator::staticGetSkeleton(testData[i], status);
1077 if (!assertSuccess("staticGetSkeleton", status)) {
1078 return;
1079 }
1080 assertEquals("Skeleton", testData[i], skeleton);
1081 }
1082 }
1083
1084 void IntlTestDateTimePatternGeneratorAPI::testC() {
1085 UErrorCode status = U_ZERO_ERROR;
1086 const int32_t numLocales = 6;
1087
1088 const char* tests[numLocales][3] = {
1089 {"zh", "Cm", "Bh:mm"},
1090 {"de", "Cm", "HH:mm"},
1091 {"en", "Cm", "h:mm a"},
1092 {"en-BN", "Cm", "h:mm b"},
1093 {"gu-IN", "Cm", "h:mm B"},
1094 {"und-IN", "Cm", "h:mm a"},
1095 };
1096
1097 for (int32_t i = 0; i < numLocales; ++i) {
1098 DateTimePatternGenerator *gen = DateTimePatternGenerator::createInstance(Locale(tests[i][0]), status);
1099 UnicodeString pattern = gen->getBestPattern(tests[i][1], status);
1100 UnicodeString expectedPattern = tests[i][2];
1101
1102 char message[100] = "\0";
1103 strcat(message, tests[i][0]);
1104 strcat(message, "/");
1105 strcat(message, tests[i][1]);
1106 assertEquals(message, expectedPattern, pattern);
1107 delete gen;
1108 }
1109 }
1110
1111 #endif /* #if !UCONFIG_NO_FORMATTING */
mirror of ICU