1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************
4 * Copyright (c) 2011-2016, International Business Machines Corporation
5 * and others. All Rights Reserved.
6 ********************************************************************/
7 /* C API TEST FOR DATE INTERVAL FORMAT */
8
9 #include "unicode/utypes.h"
10
11 #if !UCONFIG_NO_FORMATTING
12
13 #include "unicode/udateintervalformat.h"
14 #include "unicode/udat.h"
15 #include "unicode/ucal.h"
16 #include "unicode/ustring.h"
17 #include "unicode/udisplaycontext.h"
18 #include "cintltst.h"
19 #include "cmemory.h"
20 #include "cformtst.h"
21
22 static void TestDateIntervalFormat(void);
23 static void TestFPos_SkelWithSeconds(void);
24 static void TestFormatToResult(void);
25 static void TestFormatCalendarToResult(void);
26
27 void addDateIntervalFormatTest(TestNode** root);
28
29 #define TESTCASE(x) addTest(root, &x, "tsformat/cdateintervalformattest/" #x)
30
addDateIntervalFormatTest(TestNode ** root)31 void addDateIntervalFormatTest(TestNode** root)
32 {
33 TESTCASE(TestDateIntervalFormat);
34 TESTCASE(TestFPos_SkelWithSeconds);
35 TESTCASE(TestFormatToResult);
36 TESTCASE(TestFormatCalendarToResult);
37 }
38
39 static const char tzUSPacific[] = "US/Pacific";
40 static const char tzAsiaTokyo[] = "Asia/Tokyo";
41 #define Date201103021030 1299090600000.0 /* 2011-Mar-02 1030 in US/Pacific, 2011-Mar-03 0330 in Asia/Tokyo */
42 #define Date201009270800 1285599629000.0 /* 2010-Sep-27 0800 in US/Pacific */
43 #define Date158210140000 -12219379142000.0
44 #define Date158210160000 -12219206342000.0
45 #define _MINUTE (60.0*1000.0)
46 #define _HOUR (60.0*60.0*1000.0)
47 #define _DAY (24.0*60.0*60.0*1000.0)
48
49 typedef struct {
50 const char * locale;
51 const char * skeleton;
52 UDisplayContext context;
53 const char * tzid;
54 const UDate from;
55 const UDate to;
56 const UChar * resultExpected;
57 } DateIntervalFormatTestItem;
58
59 #define CAP_NONE UDISPCTX_CAPITALIZATION_NONE
60 #define CAP_BEGIN UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE
61 #define CAP_LIST UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU
62 #define CAP_ALONE UDISPCTX_CAPITALIZATION_FOR_STANDALONE
63
64 /* Just a small set of tests for now, the real functionality is tested in the C++ tests */
65 static const DateIntervalFormatTestItem testItems[] = {
66 { "en", "MMMdHHmm", CAP_NONE, tzUSPacific, Date201103021030, Date201103021030 + 7.0*_HOUR, u"Mar 2, 10:30\u2009\u2013\u200917:30" },
67 { "en", "MMMdHHmm", CAP_NONE, tzAsiaTokyo, Date201103021030, Date201103021030 + 7.0*_HOUR, u"Mar 3, 03:30\u2009\u2013\u200910:30" },
68 { "en", "yMMMEd", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 12.0*_HOUR, u"Mon, Sep 27, 2010" },
69 { "en", "yMMMEd", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 31.0*_DAY, u"Mon, Sep 27\u2009\u2013\u2009Thu, Oct 28, 2010" },
70 { "en", "yMMMEd", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 410.0*_DAY, u"Mon, Sep 27, 2010\u2009\u2013\u2009Fri, Nov 11, 2011" },
71 { "de", "Hm", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 12.0*_HOUR, u"08:00\u201320:00 Uhr" },
72 { "de", "Hm", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 31.0*_DAY, u"27.9.2010, 08:00\u2009\u2013\u200928.10.2010, 08:00" },
73 { "ja", "MMMd", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 1.0*_DAY, u"9月27日～28日" },
74 { "cs", "MMMEd", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"po 27. 9.\u2009\u2013\u2009pá 26. 11." },
75 { "cs", "yMMMM", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"září\u2013listopad 2010" },
76 { "cs", "yMMMM", CAP_NONE, tzUSPacific, Date201009270800, Date201009270800 + 1.0*_DAY, u"září 2010" },
77 #if !UCONFIG_NO_BREAK_ITERATION
78 { "cs", "MMMEd", CAP_BEGIN, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"Po 27. 9.\u2009\u2013\u2009pá 26. 11." },
79 { "cs", "yMMMM", CAP_BEGIN, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"Září\u2013listopad 2010" },
80 { "cs", "yMMMM", CAP_BEGIN, tzUSPacific, Date201009270800, Date201009270800 + 1.0*_DAY, u"Září 2010" },
81 { "cs", "MMMEd", CAP_LIST, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"Po 27. 9.\u2009\u2013\u2009pá 26. 11." },
82 { "cs", "yMMMM", CAP_LIST, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"Září\u2013listopad 2010" },
83 { "cs", "yMMMM", CAP_LIST, tzUSPacific, Date201009270800, Date201009270800 + 1.0*_DAY, u"Září 2010" },
84 { "cs", "MMMEd", CAP_ALONE, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"po 27. 9.\u2009\u2013\u2009pá 26. 11." },
85 #endif
86 { "cs", "yMMMM", CAP_ALONE, tzUSPacific, Date201009270800, Date201009270800 + 60.0*_DAY, u"září\u2013listopad 2010" },
87 { "cs", "yMMMM", CAP_ALONE, tzUSPacific, Date201009270800, Date201009270800 + 1.0*_DAY, u"září 2010" },
88 { NULL, NULL, CAP_NONE, NULL, 0, 0, NULL }
89 };
90
91 enum {
92 kSkelBufLen = 32,
93 kTZIDBufLen = 96,
94 kFormatBufLen = 128
95 };
96
TestDateIntervalFormat(void)97 static void TestDateIntervalFormat(void)
98 {
99 const DateIntervalFormatTestItem * testItemPtr;
100 UErrorCode status = U_ZERO_ERROR;
101 ctest_setTimeZone(NULL, &status);
102 log_verbose("\nTesting udtitvfmt_open() and udtitvfmt_format() with various parameters\n");
103 for ( testItemPtr = testItems; testItemPtr->locale != NULL; ++testItemPtr ) {
104 UDateIntervalFormat* udtitvfmt;
105 int32_t tzidLen;
106 UChar skelBuf[kSkelBufLen];
107 UChar tzidBuf[kTZIDBufLen];
108 const char * tzidForLog = (testItemPtr->tzid)? testItemPtr->tzid: "NULL";
109
110 status = U_ZERO_ERROR;
111 u_unescape(testItemPtr->skeleton, skelBuf, kSkelBufLen);
112 if ( testItemPtr->tzid ) {
113 u_unescape(testItemPtr->tzid, tzidBuf, kTZIDBufLen);
114 tzidLen = -1;
115 } else {
116 tzidLen = 0;
117 }
118 udtitvfmt = udtitvfmt_open(testItemPtr->locale, skelBuf, -1, tzidBuf, tzidLen, &status);
119 if ( U_SUCCESS(status) ) {
120 UChar result[kFormatBufLen];
121
122 udtitvfmt_setContext(udtitvfmt, testItemPtr->context, &status);
123 if ( U_FAILURE(status) ) {
124 log_err("FAIL: udtitvfmt_setContext for locale %s, skeleton %s, context %04X - %s\n",
125 testItemPtr->locale, testItemPtr->skeleton, (unsigned)testItemPtr->context, myErrorName(status) );
126 } else {
127 UDisplayContext getContext = udtitvfmt_getContext(udtitvfmt, UDISPCTX_TYPE_CAPITALIZATION, &status);
128 if ( U_FAILURE(status) ) {
129 log_err("FAIL: udtitvfmt_getContext for locale %s, skeleton %s, context %04X - %s\n",
130 testItemPtr->locale, testItemPtr->skeleton, (unsigned)testItemPtr->context, myErrorName(status) );
131 } else if (getContext != testItemPtr->context) {
132 log_err("FAIL: udtitvfmt_getContext for locale %s, skeleton %s, context %04X - got context %04X\n",
133 testItemPtr->locale, testItemPtr->skeleton, (unsigned)testItemPtr->context, (unsigned)getContext );
134 }
135 }
136 status = U_ZERO_ERROR;
137 int32_t fmtLen = udtitvfmt_format(udtitvfmt, testItemPtr->from, testItemPtr->to, result, kFormatBufLen, NULL, &status);
138 if (fmtLen >= kFormatBufLen) {
139 result[kFormatBufLen-1] = 0;
140 }
141 if ( U_SUCCESS(status) ) {
142 if ( u_strcmp(result, testItemPtr->resultExpected) != 0 ) {
143 char bcharBufExp[kFormatBufLen];
144 char bcharBufGet[kFormatBufLen];
145 log_err("ERROR: udtitvfmt_format for locale %s, skeleton %s, tzid %s, from %.1f, to %.1f: expect %s, get %s\n",
146 testItemPtr->locale, testItemPtr->skeleton, tzidForLog, testItemPtr->from, testItemPtr->to,
147 u_austrcpy(bcharBufExp,testItemPtr->resultExpected), u_austrcpy(bcharBufGet,result) );
148 }
149 } else {
150 log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, tzid %s, from %.1f, to %.1f: %s\n",
151 testItemPtr->locale, testItemPtr->skeleton, tzidForLog, testItemPtr->from, testItemPtr->to, myErrorName(status) );
152 }
153 udtitvfmt_close(udtitvfmt);
154 } else {
155 log_data_err("FAIL: udtitvfmt_open for locale %s, skeleton %s, tzid %s - %s\n",
156 testItemPtr->locale, testItemPtr->skeleton, tzidForLog, myErrorName(status) );
157 }
158 }
159 ctest_resetTimeZone();
160 }
161
162 /********************************************************************
163 * TestFPos_SkelWithSeconds and related data
164 ********************************************************************
165 */
166
167 static UChar zoneGMT[] = { 0x47,0x4D,0x54,0 }; // GMT
168 static const UDate startTime = 1416474000000.0; // 2014 Nov 20 09:00 GMT
169
170 static const double deltas[] = {
171 0.0, // none
172 200.0, // 200 millisec
173 20000.0, // 20 sec
174 1200000.0, // 20 min
175 7200000.0, // 2 hrs
176 43200000.0, // 12 hrs
177 691200000.0, // 8 days
178 1382400000.0, // 16 days,
179 8640000000.0, // 100 days
180 -1.0
181 };
182 enum { kNumDeltas = UPRV_LENGTHOF(deltas) - 1 };
183
184 typedef struct {
185 int32_t posBegin;
186 int32_t posEnd;
187 const char * format;
188 } ExpectPosAndFormat;
189
190 static const ExpectPosAndFormat exp_en_HHmm[kNumDeltas] = {
191 { 3, 5, "09:00" },
192 { 3, 5, "09:00" },
193 { 3, 5, "09:00" },
194 { 3, 5, "09:00\\u2009\\u2013\\u200909:20" },
195 { 3, 5, "09:00\\u2009\\u2013\\u200911:00" },
196 { 3, 5, "09:00\\u2009\\u2013\\u200921:00" },
197 { 15, 17, "11/20/2014, 09:00\\u2009\\u2013\\u200911/28/2014, 09:00" },
198 { 15, 17, "11/20/2014, 09:00\\u2009\\u2013\\u200912/6/2014, 09:00" },
199 { 15, 17, "11/20/2014, 09:00\\u2009\\u2013\\u20092/28/2015, 09:00" }
200 };
201
202 static const ExpectPosAndFormat exp_en_HHmmss[kNumDeltas] = {
203 { 3, 5, "09:00:00" },
204 { 3, 5, "09:00:00" },
205 { 3, 5, "09:00:00\\u2009\\u2013\\u200909:00:20" },
206 { 3, 5, "09:00:00\\u2009\\u2013\\u200909:20:00" },
207 { 3, 5, "09:00:00\\u2009\\u2013\\u200911:00:00" },
208 { 3, 5, "09:00:00\\u2009\\u2013\\u200921:00:00" },
209 { 15, 17, "11/20/2014, 09:00:00\\u2009\\u2013\\u200911/28/2014, 09:00:00" },
210 { 15, 17, "11/20/2014, 09:00:00\\u2009\\u2013\\u200912/6/2014, 09:00:00" },
211 { 15, 17, "11/20/2014, 09:00:00\\u2009\\u2013\\u20092/28/2015, 09:00:00" }
212 };
213
214 static const ExpectPosAndFormat exp_en_yyMMdd[kNumDeltas] = {
215 { 0, 0, "11/20/14" },
216 { 0, 0, "11/20/14" },
217 { 0, 0, "11/20/14" },
218 { 0, 0, "11/20/14" },
219 { 0, 0, "11/20/14" },
220 { 0, 0, "11/20/14" },
221 { 0, 0, "11/20/14\\u2009\\u2013\\u200911/28/14" },
222 { 0, 0, "11/20/14\\u2009\\u2013\\u200912/6/14" },
223 { 0, 0, "11/20/14\\u2009\\u2013\\u20092/28/15" }
224 };
225
226 static const ExpectPosAndFormat exp_en_yyMMddHHmm[kNumDeltas] = {
227 { 13, 15, "11/20/14, 09:00" },
228 { 13, 15, "11/20/14, 09:00" },
229 { 13, 15, "11/20/14, 09:00" },
230 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200909:20" },
231 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200911:00" },
232 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200921:00" },
233 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200911/28/14, 09:00" },
234 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200912/06/14, 09:00" },
235 { 13, 15, "11/20/14, 09:00\\u2009\\u2013\\u200902/28/15, 09:00" }
236 };
237
238 static const ExpectPosAndFormat exp_en_yyMMddHHmmss[kNumDeltas] = {
239 { 13, 15, "11/20/14, 09:00:00" },
240 { 13, 15, "11/20/14, 09:00:00" },
241 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200909:00:20" },
242 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200909:20:00" },
243 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200911:00:00" },
244 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200921:00:00" },
245 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200911/28/14, 09:00:00" },
246 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200912/06/14, 09:00:00" },
247 { 13, 15, "11/20/14, 09:00:00\\u2009\\u2013\\u200902/28/15, 09:00:00" }
248 };
249
250 static const ExpectPosAndFormat exp_en_yMMMdhmmssz[kNumDeltas] = {
251 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT" },
252 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT" },
253 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u20099:00:20\\u202FAM GMT" },
254 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u20099:20:00\\u202FAM GMT" },
255 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u200911:00:00\\u202FAM GMT" },
256 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u20099:00:00\\u202FPM GMT" },
257 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u2009Nov 28, 2014, 9:00:00\\u202FAM GMT" },
258 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u2009Dec 6, 2014, 9:00:00\\u202FAM GMT" },
259 { 16, 18, "Nov 20, 2014, 9:00:00\\u202FAM GMT\\u2009\\u2013\\u2009Feb 28, 2015, 9:00:00\\u202FAM GMT" }
260 };
261
262 static const ExpectPosAndFormat exp_ja_yyMMddHHmm[kNumDeltas] = {
263 { 11, 13, "14/11/20 9:00" },
264 { 11, 13, "14/11/20 9:00" },
265 { 11, 13, "14/11/20 9:00" },
266 { 11, 13, "14/11/20 9\\u664200\\u5206\\uFF5E9\\u664220\\u5206" },
267 { 11, 13, "14/11/20 9\\u664200\\u5206\\uFF5E11\\u664200\\u5206" },
268 { 11, 13, "14/11/20 9\\u664200\\u5206\\uFF5E21\\u664200\\u5206" },
269 { 11, 13, "14/11/20 9:00\\uFF5E14/11/28 9:00" },
270 { 11, 13, "14/11/20 9:00\\uFF5E14/12/06 9:00" },
271 { 11, 13, "14/11/20 9:00\\uFF5E15/02/28 9:00" }
272 };
273
274 static const ExpectPosAndFormat exp_ja_yyMMddHHmmss[kNumDeltas] = {
275 { 11, 13, "14/11/20 9:00:00" },
276 { 11, 13, "14/11/20 9:00:00" },
277 { 11, 13, "14/11/20 9:00:00\\uFF5E9:00:20" },
278 { 11, 13, "14/11/20 9:00:00\\uFF5E9:20:00" },
279 { 11, 13, "14/11/20 9:00:00\\uFF5E11:00:00" },
280 { 11, 13, "14/11/20 9:00:00\\uFF5E21:00:00" },
281 { 11, 13, "14/11/20 9:00:00\\uFF5E14/11/28 9:00:00" },
282 { 11, 13, "14/11/20 9:00:00\\uFF5E14/12/06 9:00:00" },
283 { 11, 13, "14/11/20 9:00:00\\uFF5E15/02/28 9:00:00" }
284 };
285
286 static const ExpectPosAndFormat exp_ja_yMMMdHHmmss[kNumDeltas] = {
287 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00" },
288 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00" },
289 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E9:00:20" },
290 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E9:20:00" },
291 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E11:00:00" },
292 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E21:00:00" },
293 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E2014\\u5E7411\\u670828\\u65E5 9:00:00" },
294 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E2014\\u5E7412\\u67086\\u65E5 9:00:00" },
295 { 14, 16, "2014\\u5E7411\\u670820\\u65E5 9:00:00\\uFF5E2015\\u5E742\\u670828\\u65E5 9:00:00" }
296 };
297
298 typedef struct {
299 const char * locale;
300 const char * skeleton;
301 UDateFormatField fieldToCheck;
302 const ExpectPosAndFormat * expected;
303 } LocaleAndSkeletonItem;
304
305 static const LocaleAndSkeletonItem locSkelItems[] = {
306 { "en", "HHmm", UDAT_MINUTE_FIELD, exp_en_HHmm },
307 { "en", "HHmmss", UDAT_MINUTE_FIELD, exp_en_HHmmss },
308 { "en", "yyMMdd", UDAT_MINUTE_FIELD, exp_en_yyMMdd },
309 { "en", "yyMMddHHmm", UDAT_MINUTE_FIELD, exp_en_yyMMddHHmm },
310 { "en", "yyMMddHHmmss", UDAT_MINUTE_FIELD, exp_en_yyMMddHHmmss },
311 { "en", "yMMMdhmmssz", UDAT_MINUTE_FIELD, exp_en_yMMMdhmmssz },
312 { "ja", "yyMMddHHmm", UDAT_MINUTE_FIELD, exp_ja_yyMMddHHmm },
313 { "ja", "yyMMddHHmmss", UDAT_MINUTE_FIELD, exp_ja_yyMMddHHmmss },
314 { "ja", "yMMMdHHmmss", UDAT_MINUTE_FIELD, exp_ja_yMMMdHHmmss },
315 { NULL, NULL, (UDateFormatField)0, NULL }
316 };
317
318 enum { kSizeUBuf = 96, kSizeBBuf = 192 };
319
TestFPos_SkelWithSeconds(void)320 static void TestFPos_SkelWithSeconds(void)
321 {
322 const LocaleAndSkeletonItem * locSkelItemPtr;
323 for (locSkelItemPtr = locSkelItems; locSkelItemPtr->locale != NULL; locSkelItemPtr++) {
324 UDateIntervalFormat* udifmt;
325 UChar ubuf[kSizeUBuf];
326 int32_t ulen, uelen;
327 UErrorCode status = U_ZERO_ERROR;
328 ulen = u_unescape(locSkelItemPtr->skeleton, ubuf, kSizeUBuf);
329 udifmt = udtitvfmt_open(locSkelItemPtr->locale, ubuf, ulen, zoneGMT, -1, &status);
330 if ( U_FAILURE(status) ) {
331 log_data_err("FAIL: udtitvfmt_open for locale %s, skeleton %s: %s\n",
332 locSkelItemPtr->locale, locSkelItemPtr->skeleton, u_errorName(status));
333 } else {
334 const double * deltasPtr = deltas;
335 const ExpectPosAndFormat * expectedPtr = locSkelItemPtr->expected;
336 for (; *deltasPtr >= 0.0; deltasPtr++, expectedPtr++) {
337 UFieldPosition fpos = { locSkelItemPtr->fieldToCheck, 0, 0 };
338 UChar uebuf[kSizeUBuf];
339 char bbuf[kSizeBBuf];
340 char bebuf[kSizeBBuf];
341 status = U_ZERO_ERROR;
342 uelen = u_unescape(expectedPtr->format, uebuf, kSizeUBuf);
343 ulen = udtitvfmt_format(udifmt, startTime, startTime + *deltasPtr, ubuf, kSizeUBuf, &fpos, &status);
344 if ( U_FAILURE(status) ) {
345 log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %.1f: %s\n",
346 locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr, u_errorName(status));
347 } else if ( ulen != uelen || u_strncmp(ubuf,uebuf,uelen) != 0 ||
348 fpos.beginIndex != expectedPtr->posBegin || fpos.endIndex != expectedPtr->posEnd ) {
349 u_strToUTF8(bbuf, kSizeBBuf, NULL, ubuf, ulen, &status);
350 u_strToUTF8(bebuf, kSizeBBuf, NULL, uebuf, uelen, &status); // convert back to get unescaped string
351 log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %12.1f, expect %d-%d \"%s\", get %d-%d \"%s\"\n",
352 locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr,
353 expectedPtr->posBegin, expectedPtr->posEnd, bebuf,
354 fpos.beginIndex, fpos.endIndex, bbuf);
355 }
356 }
357 udtitvfmt_close(udifmt);
358 }
359 }
360 }
361
TestFormatToResult(void)362 static void TestFormatToResult(void) {
363 UErrorCode ec = U_ZERO_ERROR;
364 UDateIntervalFormat* fmt = udtitvfmt_open("de", u"dMMMMyHHmm", -1, zoneGMT, -1, &ec);
365 UFormattedDateInterval* fdi = udtitvfmt_openResult(&ec);
366 assertSuccess("Opening", &ec);
367
368 {
369 const char* message = "Field position test 1";
370 const UChar* expectedString = u"27. September 2010 um 15:00\u2009\u2013\u20092. März 2011 um 18:30";
371 udtitvfmt_formatToResult(fmt, Date201009270800, Date201103021030, fdi, &ec);
372 assertSuccess("Formatting", &ec);
373 static const UFieldPositionWithCategory expectedFieldPositions[] = {
374 // category, field, begin index, end index
375 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 0, 27},
376 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 2},
377 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 4, 13},
378 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 14, 18},
379 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 22, 24},
380 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 25, 27},
381 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 30, 51},
382 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 30, 31},
383 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 33, 37},
384 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 38, 42},
385 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 46, 48},
386 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 49, 51}};
387 checkMixedFormattedValue(
388 message,
389 udtitvfmt_resultAsValue(fdi, &ec),
390 expectedString,
391 expectedFieldPositions,
392 UPRV_LENGTHOF(expectedFieldPositions));
393 }
394 {
395 const char* message = "Field position test 2";
396 const UChar* expectedString = u"27. September 2010, 15:00–22:00 Uhr";
397 udtitvfmt_formatToResult(fmt, Date201009270800, Date201009270800 + 7*_HOUR, fdi, &ec);
398 assertSuccess("Formatting", &ec);
399 static const UFieldPositionWithCategory expectedFieldPositions[] = {
400 // category, field, begin index, end index
401 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 2},
402 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 4, 13},
403 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 14, 18},
404 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 20, 25},
405 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 20, 22},
406 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 23, 25},
407 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 26, 31},
408 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 26, 28},
409 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 29, 31},
410 {UFIELD_CATEGORY_DATE, UDAT_AM_PM_FIELD, 32, 35}};
411 checkMixedFormattedValue(
412 message,
413 udtitvfmt_resultAsValue(fdi, &ec),
414 expectedString,
415 expectedFieldPositions,
416 UPRV_LENGTHOF(expectedFieldPositions));
417 }
418
419 udtitvfmt_close(fmt);
420 udtitvfmt_closeResult(fdi);
421 }
422
TestFormatCalendarToResult(void)423 static void TestFormatCalendarToResult(void) {
424 UErrorCode ec = U_ZERO_ERROR;
425 UCalendar* ucal1 = ucal_open(zoneGMT, -1, "de", UCAL_DEFAULT, &ec);
426 ucal_setMillis(ucal1, Date201009270800, &ec);
427 UCalendar* ucal2 = ucal_open(zoneGMT, -1, "de", UCAL_DEFAULT, &ec);
428 ucal_setMillis(ucal2, Date201103021030, &ec);
429 UCalendar* ucal3 = ucal_open(zoneGMT, -1, "de", UCAL_DEFAULT, &ec);
430 ucal_setMillis(ucal3, Date201009270800 + 7*_HOUR, &ec);
431 UCalendar* ucal4 = ucal_open(zoneGMT, -1, "de", UCAL_DEFAULT, &ec);
432 UCalendar* ucal5 = ucal_open(zoneGMT, -1, "de", UCAL_DEFAULT, &ec);
433
434 UDateIntervalFormat* fmt = udtitvfmt_open("de", u"dMMMMyHHmm", -1, zoneGMT, -1, &ec);
435 UFormattedDateInterval* fdi = udtitvfmt_openResult(&ec);
436 assertSuccess("Opening", &ec);
437
438 {
439 const char* message = "Field position test 1";
440 const UChar* expectedString = u"27. September 2010 um 15:00\u2009\u2013\u20092. März 2011 um 18:30";
441 udtitvfmt_formatCalendarToResult(fmt, ucal1, ucal2, fdi, &ec);
442 assertSuccess("Formatting", &ec);
443 static const UFieldPositionWithCategory expectedFieldPositions[] = {
444 // category, field, begin index, end index
445 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 0, 27},
446 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 2},
447 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 4, 13},
448 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 14, 18},
449 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 22, 24},
450 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 25, 27},
451 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 30, 51},
452 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 30, 31},
453 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 33, 37},
454 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 38, 42},
455 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 46, 48},
456 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 49, 51}};
457 checkMixedFormattedValue(
458 message,
459 udtitvfmt_resultAsValue(fdi, &ec),
460 expectedString,
461 expectedFieldPositions,
462 UPRV_LENGTHOF(expectedFieldPositions));
463 }
464 {
465 const char* message = "Field position test 2";
466 const UChar* expectedString = u"27. September 2010, 15:00–22:00 Uhr";
467 udtitvfmt_formatCalendarToResult(fmt, ucal1, ucal3, fdi, &ec);
468 assertSuccess("Formatting", &ec);
469 static const UFieldPositionWithCategory expectedFieldPositions[] = {
470 // category, field, begin index, end index
471 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 2},
472 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 4, 13},
473 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 14, 18},
474 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 20, 25},
475 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 20, 22},
476 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 23, 25},
477 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 26, 31},
478 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 26, 28},
479 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 29, 31},
480 {UFIELD_CATEGORY_DATE, UDAT_AM_PM_FIELD, 32, 35}};
481 checkMixedFormattedValue(
482 message,
483 udtitvfmt_resultAsValue(fdi, &ec),
484 expectedString,
485 expectedFieldPositions,
486 UPRV_LENGTHOF(expectedFieldPositions));
487 }
488 {
489 const char* message = "Field position test 3";
490 // Date across Julian Gregorian change date.
491 ucal_setMillis(ucal4, Date158210140000, &ec);
492 ucal_setMillis(ucal5, Date158210160000, &ec);
493 // 1 2 3 4
494 // 0123456789012345678901234 5 6 789012345678901234567890
495 const UChar* expectedString = u"4. Oktober 1582 um 00:00\u2009\u2013\u200916. Oktober 1582 um 00:00";
496 udtitvfmt_formatCalendarToResult(fmt, ucal4, ucal5, fdi, &ec);
497 assertSuccess("Formatting", &ec);
498 static const UFieldPositionWithCategory expectedFieldPositions[] = {
499 // category, field, begin index, end index
500 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 0, 24},
501 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 1},
502 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 3, 10},
503 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 11, 15},
504 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 19, 21},
505 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 22, 24},
506 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 27, 52},
507 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 27, 29},
508 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 31, 38},
509 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 39, 43},
510 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 47, 49},
511 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 50, 52}};
512 checkMixedFormattedValue(
513 message,
514 udtitvfmt_resultAsValue(fdi, &ec),
515 expectedString,
516 expectedFieldPositions,
517 UPRV_LENGTHOF(expectedFieldPositions));
518 }
519 {
520 // Date across Julian Gregorian change date.
521 // We set the Gregorian Change way back.
522 ucal_setGregorianChange(ucal5, (UDate)(-8.64e15), &ec);
523 ucal_setGregorianChange(ucal4, (UDate)(-8.64e15), &ec);
524 ucal_setMillis(ucal4, Date158210140000, &ec);
525 ucal_setMillis(ucal5, Date158210160000, &ec);
526 const char* message = "Field position test 4";
527 // 1 2 3 4
528 // 01234567890123456789012345 6 7 89012345678901234567890
529 const UChar* expectedString = u"14. Oktober 1582 um 00:00\u2009\u2013\u200916. Oktober 1582 um 00:00";
530 udtitvfmt_formatCalendarToResult(fmt, ucal4, ucal5, fdi, &ec);
531 assertSuccess("Formatting", &ec);
532 static const UFieldPositionWithCategory expectedFieldPositions[] = {
533 // category, field, begin index, end index
534 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 0, 0, 25},
535 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 0, 2},
536 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 4, 11},
537 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 12, 16},
538 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 20, 22},
539 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 23, 25},
540 {UFIELD_CATEGORY_DATE_INTERVAL_SPAN, 1, 28, 53},
541 {UFIELD_CATEGORY_DATE, UDAT_DATE_FIELD, 28, 30},
542 {UFIELD_CATEGORY_DATE, UDAT_MONTH_FIELD, 32, 39},
543 {UFIELD_CATEGORY_DATE, UDAT_YEAR_FIELD, 40, 44},
544 {UFIELD_CATEGORY_DATE, UDAT_HOUR_OF_DAY0_FIELD, 48, 50},
545 {UFIELD_CATEGORY_DATE, UDAT_MINUTE_FIELD, 51, 53}};
546 checkMixedFormattedValue(
547 message,
548 udtitvfmt_resultAsValue(fdi, &ec),
549 expectedString,
550 expectedFieldPositions,
551 UPRV_LENGTHOF(expectedFieldPositions));
552 }
553
554 ucal_close(ucal1);
555 ucal_close(ucal2);
556 ucal_close(ucal3);
557 ucal_close(ucal4);
558 ucal_close(ucal5);
559 udtitvfmt_close(fmt);
560 udtitvfmt_closeResult(fdi);
561 }
562
563 #endif /* #if !UCONFIG_NO_FORMATTING */
564