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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * This file is available under and governed by the GNU General Public
26 * License version 2 only, as published by the Free Software Foundation.
27 * However, the following notice accompanied the original version of this
28 * file:
29 *
30 * Copyright (c) 2010-2012, Stephen Colebourne & Michael Nascimento Santos
31 *
32 * All rights reserved.
33 *
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted provided that the following conditions are met:
36 *
37 * * Redistributions of source code must retain the above copyright notice,
38 * this list of conditions and the following disclaimer.
39 *
40 * * Redistributions in binary form must reproduce the above copyright notice,
41 * this list of conditions and the following disclaimer in the documentation
42 * and/or other materials provided with the distribution.
43 *
44 * * Neither the name of JSR-310 nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60 package tck.java.time.zone;
61
62 import static org.testng.Assert.assertEquals;
63
64 import tck.java.time.AbstractTCKTest;
65 import java.time.DayOfWeek;
66 import java.time.LocalDateTime;
67 import java.time.LocalTime;
68 import java.time.Month;
69 import java.time.ZoneOffset;
70 import java.time.zone.ZoneOffsetTransition;
71 import java.time.zone.ZoneOffsetTransitionRule;
72 import java.time.zone.ZoneOffsetTransitionRule.TimeDefinition;
73
74 import org.testng.annotations.Test;
75
76 /**
77 * Test ZoneOffsetTransitionRule.
78 */
79 @Test
80 public class TCKZoneOffsetTransitionRule extends AbstractTCKTest {
81
82 private static final LocalTime TIME_0100 = LocalTime.of(1, 0);
83 private static final ZoneOffset OFFSET_0200 = ZoneOffset.ofHours(2);
84 private static final ZoneOffset OFFSET_0300 = ZoneOffset.ofHours(3);
85
86 //-----------------------------------------------------------------------
87 // factory
88 //-----------------------------------------------------------------------
89 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
90 public void test_factory_nullMonth() {
91 ZoneOffsetTransitionRule.of(
92 null, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
93 OFFSET_0200, OFFSET_0200, OFFSET_0300);
94 }
95
96 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
97 public void test_factory_nullTime() {
98 ZoneOffsetTransitionRule.of(
99 Month.MARCH, 20, DayOfWeek.SUNDAY, null, false, TimeDefinition.WALL,
100 OFFSET_0200, OFFSET_0200, OFFSET_0300);
101 }
102
103 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
104 public void test_factory_nullTimeDefinition() {
105 ZoneOffsetTransitionRule.of(
106 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, null,
107 OFFSET_0200, OFFSET_0200, OFFSET_0300);
108 }
109
110 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
111 public void test_factory_nullStandardOffset() {
112 ZoneOffsetTransitionRule.of(
113 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
114 null, OFFSET_0200, OFFSET_0300);
115 }
116
117 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
118 public void test_factory_nullOffsetBefore() {
119 ZoneOffsetTransitionRule.of(
120 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
121 OFFSET_0200, null, OFFSET_0300);
122 }
123
124 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
125 public void test_factory_nullOffsetAfter() {
126 ZoneOffsetTransitionRule.of(
127 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
128 OFFSET_0200, OFFSET_0200, null);
129 }
130
131 @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
132 public void test_factory_invalidDayOfMonthIndicator_tooSmall() {
133 ZoneOffsetTransitionRule.of(
134 Month.MARCH, -29, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
135 OFFSET_0200, OFFSET_0200, OFFSET_0300);
136 }
137
138 @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
139 public void test_factory_invalidDayOfMonthIndicator_zero() {
140 ZoneOffsetTransitionRule.of(
141 Month.MARCH, 0, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
142 OFFSET_0200, OFFSET_0200, OFFSET_0300);
143 }
144
145 @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
146 public void test_factory_invalidDayOfMonthIndicator_tooLarge() {
147 ZoneOffsetTransitionRule.of(
148 Month.MARCH, 32, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
149 OFFSET_0200, OFFSET_0200, OFFSET_0300);
150 }
151
152 @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
153 public void test_factory_invalidMidnightFlag() {
154 ZoneOffsetTransitionRule.of(
155 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, true, TimeDefinition.WALL,
156 OFFSET_0200, OFFSET_0200, OFFSET_0300);
157 }
158
159 //-----------------------------------------------------------------------
160 // getters
161 //-----------------------------------------------------------------------
162 @Test
163 public void test_getters_floatingWeek() throws Exception {
164 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
165 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
166 OFFSET_0200, OFFSET_0200, OFFSET_0300);
167 assertEquals(test.getMonth(), Month.MARCH);
168 assertEquals(test.getDayOfMonthIndicator(), 20);
169 assertEquals(test.getDayOfWeek(), DayOfWeek.SUNDAY);
170 assertEquals(test.getLocalTime(), TIME_0100);
171 assertEquals(test.isMidnightEndOfDay(), false);
172 assertEquals(test.getTimeDefinition(), TimeDefinition.WALL);
173 assertEquals(test.getStandardOffset(), OFFSET_0200);
174 assertEquals(test.getOffsetBefore(), OFFSET_0200);
175 assertEquals(test.getOffsetAfter(), OFFSET_0300);
176 assertSerializable(test);
177 }
178
179 @Test
180 public void test_getters_floatingWeekBackwards() throws Exception {
181 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
182 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
183 OFFSET_0200, OFFSET_0200, OFFSET_0300);
184 assertEquals(test.getMonth(), Month.MARCH);
185 assertEquals(test.getDayOfMonthIndicator(), -1);
186 assertEquals(test.getDayOfWeek(), DayOfWeek.SUNDAY);
187 assertEquals(test.getLocalTime(), TIME_0100);
188 assertEquals(test.isMidnightEndOfDay(), false);
189 assertEquals(test.getTimeDefinition(), TimeDefinition.WALL);
190 assertEquals(test.getStandardOffset(), OFFSET_0200);
191 assertEquals(test.getOffsetBefore(), OFFSET_0200);
192 assertEquals(test.getOffsetAfter(), OFFSET_0300);
193 assertSerializable(test);
194 }
195
196 @Test
197 public void test_getters_fixedDate() throws Exception {
198 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
199 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.WALL,
200 OFFSET_0200, OFFSET_0200, OFFSET_0300);
201 assertEquals(test.getMonth(), Month.MARCH);
202 assertEquals(test.getDayOfMonthIndicator(), 20);
203 assertEquals(test.getDayOfWeek(), null);
204 assertEquals(test.getLocalTime(), TIME_0100);
205 assertEquals(test.isMidnightEndOfDay(), false);
206 assertEquals(test.getTimeDefinition(), TimeDefinition.WALL);
207 assertEquals(test.getStandardOffset(), OFFSET_0200);
208 assertEquals(test.getOffsetBefore(), OFFSET_0200);
209 assertEquals(test.getOffsetAfter(), OFFSET_0300);
210 assertSerializable(test);
211 }
212
213 @Test
214 public void test_serialization_unusualOffsets() throws Exception {
215 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
216 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
217 ZoneOffset.ofHoursMinutesSeconds(-12, -20, -50),
218 ZoneOffset.ofHoursMinutesSeconds(-4, -10, -34),
219 ZoneOffset.ofHours(-18));
220 assertSerializable(test);
221 }
222
223 @Test
224 public void test_serialization_endOfDay() throws Exception {
225 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
226 Month.MARCH, 20, DayOfWeek.FRIDAY, LocalTime.MIDNIGHT, true, TimeDefinition.UTC,
227 OFFSET_0200, OFFSET_0200, OFFSET_0300);
228 assertSerializable(test);
229 }
230
231 @Test
232 public void test_serialization_unusualTime() throws Exception {
233 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
234 Month.MARCH, 20, DayOfWeek.WEDNESDAY, LocalTime.of(13, 34, 56), false, TimeDefinition.STANDARD,
235 OFFSET_0200, OFFSET_0200, OFFSET_0300);
236 assertSerializable(test);
237 }
238
239 //-----------------------------------------------------------------------
240 // createTransition()
241 //-----------------------------------------------------------------------
242 @Test(groups={"tck"})
243 public void test_createTransition_floatingWeek_gap_notEndOfDay() {
244 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
245 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
246 OFFSET_0200, OFFSET_0200, OFFSET_0300);
247 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
248 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
249 assertEquals(test.createTransition(2000), trans);
250 }
251
252 @Test(groups={"tck"})
253 public void test_createTransition_floatingWeek_overlap_endOfDay() {
254 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
255 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
256 OFFSET_0200, OFFSET_0300, OFFSET_0200);
257 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
258 LocalDateTime.of(2000, Month.MARCH, 27, 0, 0), OFFSET_0300, OFFSET_0200);
259 assertEquals(test.createTransition(2000), trans);
260 }
261
262 @Test(groups={"tck"})
263 public void test_createTransition_floatingWeekBackwards_last() {
264 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
265 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
266 OFFSET_0200, OFFSET_0200, OFFSET_0300);
267 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
268 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
269 assertEquals(test.createTransition(2000), trans);
270 }
271
272 @Test(groups={"tck"})
273 public void test_createTransition_floatingWeekBackwards_seventhLast() {
274 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
275 Month.MARCH, -7, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
276 OFFSET_0200, OFFSET_0200, OFFSET_0300);
277 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
278 LocalDateTime.of(2000, Month.MARCH, 19, 1, 0), OFFSET_0200, OFFSET_0300);
279 assertEquals(test.createTransition(2000), trans);
280 }
281
282 @Test(groups={"tck"})
283 public void test_createTransition_floatingWeekBackwards_secondLast() {
284 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
285 Month.MARCH, -2, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
286 OFFSET_0200, OFFSET_0200, OFFSET_0300);
287 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
288 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
289 assertEquals(test.createTransition(2000), trans);
290 }
291
292 @Test(groups={"tck"})
293 public void test_createTransition_fixedDate() {
294 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
295 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
296 OFFSET_0200, OFFSET_0200, OFFSET_0300);
297 ZoneOffsetTransition trans = ZoneOffsetTransition.of(
298 LocalDateTime.of(2000, Month.MARCH, 20, 1, 0), OFFSET_0200, OFFSET_0300);
299 assertEquals(test.createTransition(2000), trans);
300 }
301
302 //-----------------------------------------------------------------------
303 // equals()
304 //-----------------------------------------------------------------------
305 @Test(groups={"tck"})
306 public void test_equals_monthDifferent() {
307 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
308 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
309 OFFSET_0200, OFFSET_0200, OFFSET_0300);
310 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
311 Month.APRIL, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
312 OFFSET_0200, OFFSET_0200, OFFSET_0300);
313 assertEquals(a.equals(a), true);
314 assertEquals(a.equals(b), false);
315 assertEquals(b.equals(a), false);
316 assertEquals(b.equals(b), true);
317 }
318
319 @Test(groups={"tck"})
320 public void test_equals_dayOfMonthDifferent() {
321 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
322 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
323 OFFSET_0200, OFFSET_0200, OFFSET_0300);
324 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
325 Month.MARCH, 21, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
326 OFFSET_0200, OFFSET_0200, OFFSET_0300);
327 assertEquals(a.equals(a), true);
328 assertEquals(a.equals(b), false);
329 assertEquals(b.equals(a), false);
330 assertEquals(b.equals(b), true);
331 }
332
333 @Test(groups={"tck"})
334 public void test_equals_dayOfWeekDifferent() {
335 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
336 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
337 OFFSET_0200, OFFSET_0200, OFFSET_0300);
338 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
339 Month.MARCH, 20, DayOfWeek.SATURDAY, TIME_0100, false, TimeDefinition.WALL,
340 OFFSET_0200, OFFSET_0200, OFFSET_0300);
341 assertEquals(a.equals(a), true);
342 assertEquals(a.equals(b), false);
343 assertEquals(b.equals(a), false);
344 assertEquals(b.equals(b), true);
345 }
346
347 @Test(groups={"tck"})
348 public void test_equals_dayOfWeekDifferentNull() {
349 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
350 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
351 OFFSET_0200, OFFSET_0200, OFFSET_0300);
352 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
353 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.WALL,
354 OFFSET_0200, OFFSET_0200, OFFSET_0300);
355 assertEquals(a.equals(a), true);
356 assertEquals(a.equals(b), false);
357 assertEquals(b.equals(a), false);
358 assertEquals(b.equals(b), true);
359 }
360
361 @Test(groups={"tck"})
362 public void test_equals_localTimeDifferent() {
363 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
364 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
365 OFFSET_0200, OFFSET_0200, OFFSET_0300);
366 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
367 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, false, TimeDefinition.WALL,
368 OFFSET_0200, OFFSET_0200, OFFSET_0300);
369 assertEquals(a.equals(a), true);
370 assertEquals(a.equals(b), false);
371 assertEquals(b.equals(a), false);
372 assertEquals(b.equals(b), true);
373 }
374
375 @Test(groups={"tck"})
376 public void test_equals_endOfDayDifferent() {
377 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
378 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, false, TimeDefinition.WALL,
379 OFFSET_0200, OFFSET_0200, OFFSET_0300);
380 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
381 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
382 OFFSET_0200, OFFSET_0200, OFFSET_0300);
383 assertEquals(a.equals(a), true);
384 assertEquals(a.equals(b), false);
385 assertEquals(b.equals(a), false);
386 assertEquals(b.equals(b), true);
387 }
388
389 @Test(groups={"tck"})
390 public void test_equals_timeDefinitionDifferent() {
391 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
392 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
393 OFFSET_0200, OFFSET_0200, OFFSET_0300);
394 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
395 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.STANDARD,
396 OFFSET_0200, OFFSET_0200, OFFSET_0300);
397 assertEquals(a.equals(a), true);
398 assertEquals(a.equals(b), false);
399 assertEquals(b.equals(a), false);
400 assertEquals(b.equals(b), true);
401 }
402
403 @Test(groups={"tck"})
404 public void test_equals_standardOffsetDifferent() {
405 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
406 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
407 OFFSET_0200, OFFSET_0200, OFFSET_0300);
408 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
409 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
410 OFFSET_0300, OFFSET_0200, OFFSET_0300);
411 assertEquals(a.equals(a), true);
412 assertEquals(a.equals(b), false);
413 assertEquals(b.equals(a), false);
414 assertEquals(b.equals(b), true);
415 }
416
417 @Test(groups={"tck"})
418 public void test_equals_offsetBeforeDifferent() {
419 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
420 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
421 OFFSET_0200, OFFSET_0200, OFFSET_0300);
422 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
423 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
424 OFFSET_0200, OFFSET_0300, OFFSET_0300);
425 assertEquals(a.equals(a), true);
426 assertEquals(a.equals(b), false);
427 assertEquals(b.equals(a), false);
428 assertEquals(b.equals(b), true);
429 }
430
431 @Test(groups={"tck"})
432 public void test_equals_offsetAfterDifferent() {
433 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
434 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
435 OFFSET_0200, OFFSET_0200, OFFSET_0300);
436 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
437 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
438 OFFSET_0200, OFFSET_0200, OFFSET_0200);
439 assertEquals(a.equals(a), true);
440 assertEquals(a.equals(b), false);
441 assertEquals(b.equals(a), false);
442 assertEquals(b.equals(b), true);
443 }
444
445 @Test(groups={"tck"})
446 public void test_equals_string_false() {
447 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
448 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
449 OFFSET_0200, OFFSET_0200, OFFSET_0300);
450 assertEquals(a.equals("TZDB"), false);
451 }
452
453 @Test(groups={"tck"})
454 public void test_equals_null_false() {
455 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
456 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
457 OFFSET_0200, OFFSET_0200, OFFSET_0300);
458 assertEquals(a.equals(null), false);
459 }
460
461 //-----------------------------------------------------------------------
462 // hashCode()
463 //-----------------------------------------------------------------------
464 @Test(groups={"tck"})
465 public void test_hashCode_floatingWeek_gap_notEndOfDay() {
466 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
467 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
468 OFFSET_0200, OFFSET_0200, OFFSET_0300);
469 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
470 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
471 OFFSET_0200, OFFSET_0200, OFFSET_0300);
472 assertEquals(a.hashCode(), b.hashCode());
473 }
474
475 @Test(groups={"tck"})
476 public void test_hashCode_floatingWeek_overlap_endOfDay_nullDayOfWeek() {
477 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
478 Month.OCTOBER, 20, null, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
479 OFFSET_0200, OFFSET_0300, OFFSET_0200);
480 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
481 Month.OCTOBER, 20, null, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
482 OFFSET_0200, OFFSET_0300, OFFSET_0200);
483 assertEquals(a.hashCode(), b.hashCode());
484 }
485
486 @Test(groups={"tck"})
487 public void test_hashCode_floatingWeekBackwards() {
488 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
489 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
490 OFFSET_0200, OFFSET_0200, OFFSET_0300);
491 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
492 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
493 OFFSET_0200, OFFSET_0200, OFFSET_0300);
494 assertEquals(a.hashCode(), b.hashCode());
495 }
496
497 @Test(groups={"tck"})
498 public void test_hashCode_fixedDate() {
499 ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
500 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
501 OFFSET_0200, OFFSET_0200, OFFSET_0300);
502 ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
503 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
504 OFFSET_0200, OFFSET_0200, OFFSET_0300);
505 assertEquals(a.hashCode(), b.hashCode());
506 }
507
508 //-----------------------------------------------------------------------
509 // toString()
510 //-----------------------------------------------------------------------
511 @Test(groups={"tck"})
512 public void test_toString_floatingWeek_gap_notEndOfDay() {
513 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
514 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
515 OFFSET_0200, OFFSET_0200, OFFSET_0300);
516 assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, SUNDAY on or after MARCH 20 at 01:00 WALL, standard offset +02:00]");
517 }
518
519 @Test(groups={"tck"})
520 public void test_toString_floatingWeek_overlap_endOfDay() {
521 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
522 Month.OCTOBER, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
523 OFFSET_0200, OFFSET_0300, OFFSET_0200);
524 assertEquals(test.toString(), "TransitionRule[Overlap +03:00 to +02:00, SUNDAY on or after OCTOBER 20 at 24:00 WALL, standard offset +02:00]");
525 }
526
527 @Test(groups={"tck"})
528 public void test_toString_floatingWeekBackwards_last() {
529 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
530 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
531 OFFSET_0200, OFFSET_0200, OFFSET_0300);
532 assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, SUNDAY on or before last day of MARCH at 01:00 WALL, standard offset +02:00]");
533 }
534
535 @Test(groups={"tck"})
536 public void test_toString_floatingWeekBackwards_secondLast() {
537 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
538 Month.MARCH, -2, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
539 OFFSET_0200, OFFSET_0200, OFFSET_0300);
540 assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, SUNDAY on or before last day minus 1 of MARCH at 01:00 WALL, standard offset +02:00]");
541 }
542
543 @Test(groups={"tck"})
544 public void test_toString_fixedDate() {
545 ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
546 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
547 OFFSET_0200, OFFSET_0200, OFFSET_0300);
548 assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, MARCH 20 at 01:00 STANDARD, standard offset +02:00]");
549 }
550
551 }