1 /*
2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
28 *
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions are met:
33 *
34 * * Redistributions of source code must retain the above copyright notice,
35 * this list of conditions and the following disclaimer.
36 *
37 * * Redistributions in binary form must reproduce the above copyright notice,
38 * this list of conditions and the following disclaimer in the documentation
39 * and/or other materials provided with the distribution.
40 *
41 * * Neither the name of JSR-310 nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
46 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
47 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
48 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
49 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
50 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
53 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
54 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
55 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 */
57 package tck.java.time.temporal;
58
59 import static java.time.temporal.ChronoField.DAY_OF_MONTH;
60 import static java.time.temporal.ChronoField.DAY_OF_WEEK;
61 import static java.time.temporal.ChronoField.DAY_OF_YEAR;
62 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
63 import static java.time.temporal.ChronoField.YEAR;
64
65 import static org.testng.Assert.assertEquals;
66 import static org.testng.Assert.assertSame;
67
68 import java.io.IOException;
69 import java.time.DayOfWeek;
70 import java.time.LocalDate;
71 import java.time.format.DateTimeFormatter;
72 import java.time.format.DateTimeFormatterBuilder;
73 import java.time.temporal.ChronoUnit;
74 import java.time.temporal.JulianFields;
75 import java.time.temporal.TemporalField;
76 import java.time.temporal.ValueRange;
77 import java.time.temporal.WeekFields;
78
79 import org.testng.annotations.DataProvider;
80 import org.testng.annotations.Test;
81 import tck.java.time.AbstractTCKTest;
82
83 /**
84 * Test WeekFields.
85 */
86 @Test
87 public class TCKWeekFields extends AbstractTCKTest {
88
89 @Test(dataProvider="weekFields")
90 public void test_of_DayOfWeek_int_singleton(DayOfWeek firstDayOfWeek, int minDays) {
91 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
92 assertEquals(week.getFirstDayOfWeek(), firstDayOfWeek, "Incorrect firstDayOfWeek");
93 assertEquals(week.getMinimalDaysInFirstWeek(), minDays, "Incorrect MinimalDaysInFirstWeek");
94 assertSame(WeekFields.of(firstDayOfWeek, minDays), week);
95 }
96
97 //-----------------------------------------------------------------------
98 @Test(dataProvider="weekFields")
99 public void test_basics(DayOfWeek firstDayOfWeek, int minDays) {
100 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
101 assertEquals(week.dayOfWeek().isDateBased(), true);
102 assertEquals(week.dayOfWeek().isTimeBased(), false);
103
104 assertEquals(week.weekOfMonth().isDateBased(), true);
105 assertEquals(week.weekOfMonth().isTimeBased(), false);
106
107 assertEquals(week.weekOfYear().isDateBased(), true);
108 assertEquals(week.weekOfYear().isTimeBased(), false);
109
110 assertEquals(week.weekOfWeekBasedYear().isDateBased(), true);
111 assertEquals(week.weekOfWeekBasedYear().isTimeBased(), false);
112
113 assertEquals(week.weekBasedYear().isDateBased(), true);
114 assertEquals(week.weekBasedYear().isTimeBased(), false);
115 }
116
117 //-----------------------------------------------------------------------
118 @Test
119 public void test_dayOfWeekField_simpleGet() {
120 LocalDate date = LocalDate.of(2000, 1, 10); // Known to be ISO Monday
121 assertEquals(date.get(WeekFields.ISO.dayOfWeek()), 1);
122 assertEquals(date.get(WeekFields.of(DayOfWeek.MONDAY, 1).dayOfWeek()), 1);
123 assertEquals(date.get(WeekFields.of(DayOfWeek.MONDAY, 7).dayOfWeek()), 1);
124 assertEquals(date.get(WeekFields.SUNDAY_START.dayOfWeek()), 2);
125 assertEquals(date.get(WeekFields.of(DayOfWeek.SUNDAY, 1).dayOfWeek()), 2);
126 assertEquals(date.get(WeekFields.of(DayOfWeek.SUNDAY, 7).dayOfWeek()), 2);
127 assertEquals(date.get(WeekFields.of(DayOfWeek.SATURDAY, 1).dayOfWeek()), 3);
128 assertEquals(date.get(WeekFields.of(DayOfWeek.FRIDAY, 1).dayOfWeek()), 4);
129 assertEquals(date.get(WeekFields.of(DayOfWeek.TUESDAY, 1).dayOfWeek()), 7);
130 }
131
132 @Test
133 public void test_dayOfWeekField_simpleSet() {
134 LocalDate date = LocalDate.of(2000, 1, 10); // Known to be ISO Monday
135 assertEquals(date.with(WeekFields.ISO.dayOfWeek(), 2), LocalDate.of(2000, 1, 11));
136 assertEquals(date.with(WeekFields.ISO.dayOfWeek(), 7), LocalDate.of(2000, 1, 16));
137
138 assertEquals(date.with(WeekFields.SUNDAY_START.dayOfWeek(), 3), LocalDate.of(2000, 1, 11));
139 assertEquals(date.with(WeekFields.SUNDAY_START.dayOfWeek(), 7), LocalDate.of(2000, 1, 15));
140
141 assertEquals(date.with(WeekFields.of(DayOfWeek.SATURDAY, 1).dayOfWeek(), 4), LocalDate.of(2000, 1, 11));
142 assertEquals(date.with(WeekFields.of(DayOfWeek.TUESDAY, 1).dayOfWeek(), 1), LocalDate.of(2000, 1, 4));
143 }
144
145 @Test(dataProvider="weekFields")
146 public void test_dayOfWeekField(DayOfWeek firstDayOfWeek, int minDays) {
147 LocalDate day = LocalDate.of(2000, 1, 10); // Known to be ISO Monday
148 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
149 TemporalField f = week.dayOfWeek();
150
151 for (int i = 1; i <= 7; i++) {
152 assertEquals(day.get(f), (7 + day.getDayOfWeek().getValue() - firstDayOfWeek.getValue()) % 7 + 1);
153 day = day.plusDays(1);
154 }
155 }
156
157 @Test(dataProvider="weekFields")
158 public void test_weekOfMonthField(DayOfWeek firstDayOfWeek, int minDays) {
159 LocalDate day = LocalDate.of(2012, 12, 31); // Known to be ISO Monday
160 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
161 TemporalField dowField = week.dayOfWeek();
162 TemporalField womField = week.weekOfMonth();
163
164 DayOfWeek isoDOW = day.getDayOfWeek();
165 int dow = (7 + isoDOW.getValue() - firstDayOfWeek.getValue()) % 7 + 1;
166
167 for (int i = 1; i <= 15; i++) {
168 int actualDOW = day.get(dowField);
169 int actualWOM = day.get(womField);
170
171 // Verify that the combination of day of week and week of month can be used
172 // to reconstruct the same date.
173 LocalDate day1 = day.withDayOfMonth(1);
174 int offset = - (day1.get(dowField) - 1);
175
176 int week1 = day1.get(womField);
177 if (week1 == 0) {
178 // week of the 1st is partial; start with first full week
179 offset += 7;
180 }
181
182 offset += actualDOW - 1;
183 offset += (actualWOM - 1) * 7;
184 LocalDate result = day1.plusDays(offset);
185
186 assertEquals(result, day, "Incorrect dayOfWeek or weekOfMonth: "
187 + String.format("%s, ISO Dow: %s, offset: %s, actualDOW: %s, actualWOM: %s, expected: %s, result: %s%n",
188 week, day.getDayOfWeek(), offset, actualDOW, actualWOM, day, result));
189 day = day.plusDays(1);
190 }
191 }
192
193 @Test(dataProvider="weekFields")
194 public void test_weekOfYearField(DayOfWeek firstDayOfWeek, int minDays) {
195 LocalDate day = LocalDate.of(2012, 12, 31); // Known to be ISO Monday
196 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
197 TemporalField dowField = week.dayOfWeek();
198 TemporalField woyField = week.weekOfYear();
199
200 DayOfWeek isoDOW = day.getDayOfWeek();
201 int dow = (7 + isoDOW.getValue() - firstDayOfWeek.getValue()) % 7 + 1;
202
203 for (int i = 1; i <= 15; i++) {
204 int actualDOW = day.get(dowField);
205 int actualWOY = day.get(woyField);
206
207 // Verify that the combination of day of week and week of month can be used
208 // to reconstruct the same date.
209 LocalDate day1 = day.withDayOfYear(1);
210 int offset = - (day1.get(dowField) - 1);
211 int week1 = day1.get(woyField);
212 if (week1 == 0) {
213 // week of the 1st is partial; start with first full week
214 offset += 7;
215 }
216 offset += actualDOW - 1;
217 offset += (actualWOY - 1) * 7;
218 LocalDate result = day1.plusDays(offset);
219
220 assertEquals(result, day, "Incorrect dayOfWeek or weekOfYear "
221 + String.format("%s, ISO Dow: %s, offset: %s, actualDOW: %s, actualWOM: %s, expected: %s, result: %s%n",
222 week, day.getDayOfWeek(), offset, actualDOW, actualWOY, day, result));
223 day = day.plusDays(1);
224 }
225 }
226
227 /**
228 * Verify that the date can be reconstructed from the DOW, WeekOfWeekBasedYear,
229 * and WeekBasedYear for every combination of start of week
230 * and minimal days in week.
231 * @param firstDayOfWeek the first day of the week
232 * @param minDays the minimum number of days in the week
233 */
234 @Test(dataProvider="weekFields")
235 public void test_weekOfWeekBasedYearField(DayOfWeek firstDayOfWeek, int minDays) {
236 LocalDate day = LocalDate.of(2012, 12, 31); // Known to be ISO Monday
237 WeekFields weekDef = WeekFields.of(firstDayOfWeek, minDays);
238 TemporalField dowField = weekDef.dayOfWeek();
239 TemporalField wowbyField = weekDef.weekOfWeekBasedYear();
240 TemporalField yowbyField = weekDef.weekBasedYear();
241
242 for (int i = 1; i <= 15; i++) {
243 int actualDOW = day.get(dowField);
244 int actualWOWBY = day.get(wowbyField);
245 int actualYOWBY = day.get(yowbyField);
246
247 // Verify that the combination of day of week and week of month can be used
248 // to reconstruct the same date.
249 LocalDate day1 = LocalDate.of(actualYOWBY, 1, 1);
250 DayOfWeek isoDOW = day1.getDayOfWeek();
251 int dow = (7 + isoDOW.getValue() - firstDayOfWeek.getValue()) % 7 + 1;
252
253 int weekStart = Math.floorMod(1 - dow, 7);
254 if (weekStart + 1 > weekDef.getMinimalDaysInFirstWeek()) {
255 // The previous week has the minimum days in the current month to be a 'week'
256 weekStart -= 7;
257 }
258 weekStart += actualDOW - 1;
259 weekStart += (actualWOWBY - 1) * 7;
260 LocalDate result = day1.plusDays(weekStart);
261
262 assertEquals(result, day, "Incorrect dayOfWeek or weekOfYear "
263 + String.format("%s, ISO Dow: %s, weekStart: %s, actualDOW: %s, actualWOWBY: %s, YearOfWBY: %d, expected day: %s, result: %s%n",
264 weekDef, day.getDayOfWeek(), weekStart, actualDOW, actualWOWBY, actualYOWBY, day, result));
265 day = day.plusDays(1);
266 }
267 }
268
269 @Test(dataProvider="weekFields")
270 public void test_fieldRanges(DayOfWeek firstDayOfWeek, int minDays) {
271 WeekFields weekDef = WeekFields.of(firstDayOfWeek, minDays);
272 TemporalField womField = weekDef.weekOfMonth();
273 TemporalField woyField = weekDef.weekOfYear();
274
275 LocalDate day = LocalDate.of(2012, 11, 30);
276 LocalDate endDay = LocalDate.of(2013, 1, 2);
277 while (day.isBefore(endDay)) {
278 LocalDate last = day.with(DAY_OF_MONTH, day.lengthOfMonth());
279 int lastWOM = last.get(womField);
280 LocalDate first = day.with(DAY_OF_MONTH, 1);
281 int firstWOM = first.get(womField);
282 ValueRange rangeWOM = day.range(womField);
283 assertEquals(rangeWOM.getMinimum(), firstWOM,
284 "Range min should be same as WeekOfMonth for first day of month: "
285 + first + ", " + weekDef);
286 assertEquals(rangeWOM.getMaximum(), lastWOM,
287 "Range max should be same as WeekOfMonth for last day of month: "
288 + last + ", " + weekDef);
289
290 last = day.with(DAY_OF_YEAR, day.lengthOfYear());
291 int lastWOY = last.get(woyField);
292 first = day.with(DAY_OF_YEAR, 1);
293 int firstWOY = first.get(woyField);
294 ValueRange rangeWOY = day.range(woyField);
295 assertEquals(rangeWOY.getMinimum(), firstWOY,
296 "Range min should be same as WeekOfYear for first day of Year: "
297 + day + ", " + weekDef);
298 assertEquals(rangeWOY.getMaximum(), lastWOY,
299 "Range max should be same as WeekOfYear for last day of Year: "
300 + day + ", " + weekDef);
301
302 day = day.plusDays(1);
303 }
304 }
305
306 //-----------------------------------------------------------------------
307 // withDayOfWeek()
308 //-----------------------------------------------------------------------
309 @Test(dataProvider="weekFields")
310 public void test_withDayOfWeek(DayOfWeek firstDayOfWeek, int minDays) {
311 LocalDate day = LocalDate.of(2012, 12, 15); // Safely in the middle of a month
312 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
313 TemporalField dowField = week.dayOfWeek();
314 TemporalField womField = week.weekOfMonth();
315 TemporalField woyField = week.weekOfYear();
316
317 int wom = day.get(womField);
318 int woy = day.get(woyField);
319 for (int dow = 1; dow <= 7; dow++) {
320 LocalDate result = day.with(dowField, dow);
321 assertEquals(result.get(dowField), dow, String.format("Incorrect new Day of week: %s", result));
322 assertEquals(result.get(womField), wom, "Week of Month should not change");
323 assertEquals(result.get(woyField), woy, "Week of Year should not change");
324 }
325 }
326
327 @Test(dataProvider="weekFields")
328 public void test_rangeWeekOfWeekBasedYear(DayOfWeek firstDayOfWeek, int minDays) {
329 WeekFields weekFields = WeekFields.of(firstDayOfWeek, minDays);
330 TemporalField dowField = weekFields.dayOfWeek();
331 TemporalField wowByField = weekFields.weekOfWeekBasedYear();
332
333 LocalDate day1 = LocalDate.of(2012, 1, weekFields.getMinimalDaysInFirstWeek());
334 day1 = day1.with(wowByField, 1).with(dowField, 1);
335
336 LocalDate day2 = LocalDate.of(2013, 1, weekFields.getMinimalDaysInFirstWeek());
337 day2 = day2.with(wowByField, 1).with(dowField, 1);
338
339 int expectedWeeks = (int)ChronoUnit.DAYS.between(day1, day2) / 7;
340
341 ValueRange range = day1.range(wowByField);
342 assertEquals(range.getMaximum(), expectedWeeks, "Range incorrect");
343 }
344
345 @Test(dataProvider="weekFields")
346 public void test_withWeekOfWeekBasedYear(DayOfWeek firstDayOfWeek, int minDays) {
347 LocalDate day = LocalDate.of(2012, 12, 31);
348 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
349 TemporalField dowField = week.dayOfWeek();
350 TemporalField wowbyField = week.weekOfWeekBasedYear();
351 TemporalField yowbyField = week.weekBasedYear();
352
353 int dowExpected = (day.get(dowField) - 1) % 7 + 1;
354 LocalDate dowDate = day.with(dowField, dowExpected);
355 int dowResult = dowDate.get(dowField);
356 assertEquals(dowResult, dowExpected, "Localized DayOfWeek not correct; " + day + " -->" + dowDate);
357
358 int weekExpected = day.get(wowbyField) + 1;
359 ValueRange range = day.range(wowbyField);
360 weekExpected = ((weekExpected - 1) % (int)range.getMaximum()) + 1;
361 LocalDate weekDate = day.with(wowbyField, weekExpected);
362 int weekResult = weekDate.get(wowbyField);
363 assertEquals(weekResult, weekExpected, "Localized WeekOfWeekBasedYear not correct; " + day + " -->" + weekDate);
364
365 int yearExpected = day.get(yowbyField) + 1;
366
367 LocalDate yearDate = day.with(yowbyField, yearExpected);
368 int yearResult = yearDate.get(yowbyField);
369 assertEquals(yearResult, yearExpected, "Localized WeekBasedYear not correct; " + day + " --> " + yearDate);
370
371 range = yearDate.range(wowbyField);
372 weekExpected = Math.min(day.get(wowbyField), (int)range.getMaximum());
373
374 int weekActual = yearDate.get(wowbyField);
375 assertEquals(weekActual, weekExpected, "Localized WeekOfWeekBasedYear week should not change; " + day + " --> " + yearDate + ", actual: " + weekActual + ", weekExpected: " + weekExpected);
376 }
377
378 //-----------------------------------------------------------------------
379 @Test(dataProvider="weekFields")
380 public void test_parse_resolve_localizedWom(DayOfWeek firstDayOfWeek, int minDays) {
381 LocalDate date = LocalDate.of(2012, 12, 15);
382 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
383 TemporalField womField = week.weekOfMonth();
384
385 for (int i = 1; i <= 60; i++) {
386 // Test that with dayOfWeek and Week of month it computes the date
387 DateTimeFormatter f = new DateTimeFormatterBuilder()
388 .appendValue(YEAR).appendLiteral('-')
389 .appendValue(MONTH_OF_YEAR).appendLiteral('-')
390 .appendValue(womField).appendLiteral('-')
391 .appendValue(DAY_OF_WEEK).toFormatter();
392 String str = date.getYear() + "-" + date.getMonthValue() + "-" +
393 date.get(womField) + "-" + date.get(DAY_OF_WEEK);
394 LocalDate parsed = LocalDate.parse(str, f);
395 assertEquals(parsed, date, " ::" + str + "::" + i);
396
397 date = date.plusDays(1);
398 }
399 }
400
401 @Test(dataProvider="weekFields")
402 public void test_parse_resolve_localizedWomDow(DayOfWeek firstDayOfWeek, int minDays) {
403 LocalDate date = LocalDate.of(2012, 12, 15);
404 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
405 TemporalField dowField = week.dayOfWeek();
406 TemporalField womField = week.weekOfMonth();
407
408 for (int i = 1; i <= 15; i++) {
409 // Test that with dayOfWeek and Week of month it computes the date
410 DateTimeFormatter f = new DateTimeFormatterBuilder()
411 .appendValue(YEAR).appendLiteral('-')
412 .appendValue(MONTH_OF_YEAR).appendLiteral('-')
413 .appendValue(womField).appendLiteral('-')
414 .appendValue(dowField).toFormatter();
415 String str = date.getYear() + "-" + date.getMonthValue() + "-" +
416 date.get(womField) + "-" + date.get(dowField);
417 LocalDate parsed = LocalDate.parse(str, f);
418 assertEquals(parsed, date, " :: " + str + " " + i);
419
420 date = date.plusDays(1);
421 }
422 }
423
424 @Test(dataProvider="weekFields")
425 public void test_parse_resolve_localizedWoy(DayOfWeek firstDayOfWeek, int minDays) {
426 LocalDate date = LocalDate.of(2012, 12, 15);
427 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
428 TemporalField woyField = week.weekOfYear();
429
430 for (int i = 1; i <= 60; i++) {
431 // Test that with dayOfWeek and Week of month it computes the date
432 DateTimeFormatter f = new DateTimeFormatterBuilder()
433 .appendValue(YEAR).appendLiteral('-')
434 .appendValue(MONTH_OF_YEAR).appendLiteral('-')
435 .appendValue(woyField).appendLiteral('-')
436 .appendValue(DAY_OF_WEEK).toFormatter();
437 String str = date.getYear() + "-" + date.getMonthValue() + "-" +
438 date.get(woyField) + "-" + date.get(DAY_OF_WEEK);
439 LocalDate parsed = LocalDate.parse(str, f);
440 assertEquals(parsed, date, " :: " + str + " " + i);
441
442 date = date.plusDays(1);
443 }
444 }
445
446 @Test(dataProvider="weekFields")
447 public void test_parse_resolve_localizedWoyDow(DayOfWeek firstDayOfWeek, int minDays) {
448 LocalDate date = LocalDate.of(2012, 12, 15);
449 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
450 TemporalField dowField = week.dayOfWeek();
451 TemporalField woyField = week.weekOfYear();
452
453 for (int i = 1; i <= 60; i++) {
454 // Test that with dayOfWeek and Week of month it computes the date
455 DateTimeFormatter f = new DateTimeFormatterBuilder()
456 .appendValue(YEAR).appendLiteral('-')
457 .appendValue(MONTH_OF_YEAR).appendLiteral('-')
458 .appendValue(woyField).appendLiteral('-')
459 .appendValue(dowField).toFormatter();
460 String str = date.getYear() + "-" + date.getMonthValue() + "-" +
461 date.get(woyField) + "-" + date.get(dowField);
462 LocalDate parsed = LocalDate.parse(str, f);
463 assertEquals(parsed, date, " :: " + str + " " + i);
464
465 date = date.plusDays(1);
466 }
467 }
468
469 @Test(dataProvider="weekFields")
470 public void test_parse_resolve_localizedWoWBY(DayOfWeek firstDayOfWeek, int minDays) {
471 LocalDate date = LocalDate.of(2012, 12, 31);
472 WeekFields week = WeekFields.of(firstDayOfWeek, minDays);
473 TemporalField dowField = week.dayOfWeek();
474 TemporalField wowbyField = week.weekOfWeekBasedYear();
475 TemporalField yowbyField = week.weekBasedYear();
476
477 for (int i = 1; i <= 60; i++) {
478 // Test that with dayOfWeek, week of year and year of week-based-year it computes the date
479 DateTimeFormatter f = new DateTimeFormatterBuilder()
480 .appendValue(yowbyField).appendLiteral('-')
481 .appendValue(wowbyField).appendLiteral('-')
482 .appendValue(dowField).toFormatter();
483 String str = date.get(yowbyField) + "-" + date.get(wowbyField) + "-" +
484 date.get(dowField);
485 LocalDate parsed = LocalDate.parse(str, f);
486 assertEquals(parsed, date, " :: " + str + " " + i);
487
488 date = date.plusDays(1);
489 }
490 }
491
492 //-----------------------------------------------------------------------
493 @Test(dataProvider="weekFields")
494 public void test_serializable_singleton(DayOfWeek firstDayOfWeek, int minDays) throws IOException, ClassNotFoundException {
495 WeekFields weekDef = WeekFields.of(firstDayOfWeek, minDays);
496 assertSerializableSame(weekDef); // spec state singleton
497 }
498
499 //-----------------------------------------------------------------------
500 @DataProvider(name="weekFields")
501 Object[][] data_weekFields() {
502 Object[][] objects = new Object[49][];
503 int i = 0;
504 for (DayOfWeek firstDayOfWeek : DayOfWeek.values()) {
505 for (int minDays = 1; minDays <= 7; minDays++) {
506 objects[i++] = new Object[] {firstDayOfWeek, minDays};
507 }
508 }
509 return objects;
510 }
511
512 //-----------------------------------------------------------------------
513 @DataProvider(name="WeekBasedYearData")
514 Object[][] provider_WeekBasedYearData() {
515 return new Object[][] {
516 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2008, 52, 7, LocalDate.of(2008, 12, 27)},
517 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 1, 1, LocalDate.of(2008, 12, 28)},
518 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 1, 2, LocalDate.of(2008, 12, 29)},
519 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 1, 3, LocalDate.of(2008, 12, 30)},
520 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 1, 4, LocalDate.of(2008, 12, 31)},
521 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 1, 5, LocalDate.of(2009, 1, 1)},
522 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 2, 1, LocalDate.of(2009, 1, 4)},
523 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 2, 2, LocalDate.of(2009, 1, 5)},
524 {WeekFields.of(DayOfWeek.SUNDAY, 1), 2009, 2, 3, LocalDate.of(2009, 1, 6)},
525 };
526 }
527
528 @Test(dataProvider="WeekBasedYearData")
529 public void test_weekBasedYears(WeekFields weekDef, int weekBasedYear,
530 int weekOfWeekBasedYear, int dayOfWeek, LocalDate date) {
531 TemporalField dowField = weekDef.dayOfWeek();
532 TemporalField wowbyField = weekDef.weekOfWeekBasedYear();
533 TemporalField yowbyField = weekDef.weekBasedYear();
534 assertEquals(date.get(dowField), dayOfWeek, "DayOfWeek mismatch");
535 assertEquals(date.get(wowbyField), weekOfWeekBasedYear, "Week of WeekBasedYear mismatch");
536 assertEquals(date.get(yowbyField), weekBasedYear, "Year of WeekBasedYear mismatch");
537 }
538
539
540 //-----------------------------------------------------------------------
541 @DataProvider(name="IsoWeekData")
542 Object[][] data_week() {
543 return new Object[][] {
544 {LocalDate.of(1969, 12, 29), DayOfWeek.MONDAY, 1, 1970},
545 {LocalDate.of(2012, 12, 23), DayOfWeek.SUNDAY, 51, 2012},
546 {LocalDate.of(2012, 12, 24), DayOfWeek.MONDAY, 52, 2012},
547 {LocalDate.of(2012, 12, 27), DayOfWeek.THURSDAY, 52, 2012},
548 {LocalDate.of(2012, 12, 28), DayOfWeek.FRIDAY, 52, 2012},
549 {LocalDate.of(2012, 12, 29), DayOfWeek.SATURDAY, 52, 2012},
550 {LocalDate.of(2012, 12, 30), DayOfWeek.SUNDAY, 52, 2012},
551 {LocalDate.of(2012, 12, 31), DayOfWeek.MONDAY, 1, 2013},
552 {LocalDate.of(2013, 1, 1), DayOfWeek.TUESDAY, 1, 2013},
553 {LocalDate.of(2013, 1, 2), DayOfWeek.WEDNESDAY, 1, 2013},
554 {LocalDate.of(2013, 1, 6), DayOfWeek.SUNDAY, 1, 2013},
555 {LocalDate.of(2013, 1, 7), DayOfWeek.MONDAY, 2, 2013},
556 };
557 }
558
559 //-----------------------------------------------------------------------
560 // WEEK_OF_WEEK_BASED_YEAR
561 // Validate with the same data used by IsoFields.
562 //-----------------------------------------------------------------------
563 @Test(dataProvider="IsoWeekData")
564 public void test_WOWBY(LocalDate date, DayOfWeek dow, int week, int wby) {
565 WeekFields weekDef = WeekFields.ISO;
566 TemporalField dowField = weekDef.dayOfWeek();
567 TemporalField wowbyField = weekDef.weekOfWeekBasedYear();
568 TemporalField yowbyField = weekDef.weekBasedYear();
569
570 assertEquals(date.get(dowField), dow.getValue());
571 assertEquals(date.get(wowbyField), week);
572 assertEquals(date.get(yowbyField), wby);
573 }
574
575 }