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