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