test/java/time/tck/java/time/zone/TCKZoneOffsetTransitionRule.java

Print this page

        

@@ -59,21 +59,21 @@
  */
 package tck.java.time.zone;
 
 import static org.testng.Assert.assertEquals;
 
-import tck.java.time.AbstractTCKTest;
 import java.time.DayOfWeek;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Month;
 import java.time.ZoneOffset;
 import java.time.zone.ZoneOffsetTransition;
 import java.time.zone.ZoneOffsetTransitionRule;
 import java.time.zone.ZoneOffsetTransitionRule.TimeDefinition;
 
 import org.testng.annotations.Test;
+import tck.java.time.AbstractTCKTest;
 
 /**
  * Test ZoneOffsetTransitionRule.
  */
 @Test

@@ -84,74 +84,74 @@
     private static final ZoneOffset OFFSET_0300 = ZoneOffset.ofHours(3);
 
     //-----------------------------------------------------------------------
     // factory
     //-----------------------------------------------------------------------
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullMonth() {
         ZoneOffsetTransitionRule.of(
                 null, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullTime() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, null, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullTimeDefinition() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, null,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullStandardOffset() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 null, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullOffsetBefore() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, null, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
+    @Test(expectedExceptions=NullPointerException.class)
     public void test_factory_nullOffsetAfter() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, null);
     }
 
-    @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
+    @Test(expectedExceptions=IllegalArgumentException.class)
     public void test_factory_invalidDayOfMonthIndicator_tooSmall() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, -29, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
+    @Test(expectedExceptions=IllegalArgumentException.class)
     public void test_factory_invalidDayOfMonthIndicator_zero() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 0, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
+    @Test(expectedExceptions=IllegalArgumentException.class)
     public void test_factory_invalidDayOfMonthIndicator_tooLarge() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 32, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }
 
-    @Test(expectedExceptions=IllegalArgumentException.class, groups={"tck"})
+    @Test(expectedExceptions=IllegalArgumentException.class)
     public void test_factory_invalidMidnightFlag() {
         ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, true, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
     }

@@ -237,61 +237,61 @@
     }
 
     //-----------------------------------------------------------------------
     // createTransition()
     //-----------------------------------------------------------------------
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_floatingWeek_gap_notEndOfDay() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(
                 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
         assertEquals(test.createTransition(2000), trans);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_floatingWeek_overlap_endOfDay() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0300, OFFSET_0200);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(
                 LocalDateTime.of(2000, Month.MARCH, 27, 0, 0), OFFSET_0300, OFFSET_0200);
         assertEquals(test.createTransition(2000), trans);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_floatingWeekBackwards_last() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(
                 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
         assertEquals(test.createTransition(2000), trans);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_floatingWeekBackwards_seventhLast() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -7, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(
                 LocalDateTime.of(2000, Month.MARCH, 19, 1, 0), OFFSET_0200, OFFSET_0300);
         assertEquals(test.createTransition(2000), trans);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_floatingWeekBackwards_secondLast() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -2, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(
                 LocalDateTime.of(2000, Month.MARCH, 26, 1, 0), OFFSET_0200, OFFSET_0300);
         assertEquals(test.createTransition(2000), trans);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_createTransition_fixedDate() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransition trans = ZoneOffsetTransition.of(

@@ -300,11 +300,11 @@
     }
 
     //-----------------------------------------------------------------------
     // equals()
     //-----------------------------------------------------------------------
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_monthDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -314,11 +314,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_dayOfMonthDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -328,11 +328,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_dayOfWeekDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -342,11 +342,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_dayOfWeekDifferentNull() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -356,11 +356,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_localTimeDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -370,11 +370,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_endOfDayDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -384,11 +384,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_timeDefinitionDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -398,11 +398,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_standardOffsetDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -412,11 +412,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_offsetBeforeDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -426,11 +426,11 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_offsetAfterDifferent() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -440,63 +440,63 @@
         assertEquals(a.equals(b), false);
         assertEquals(b.equals(a), false);
         assertEquals(b.equals(b), true);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_string_false() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(a.equals("TZDB"), false);
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_equals_null_false() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(a.equals(null), false);
     }
 
     //-----------------------------------------------------------------------
     // hashCode()
     //-----------------------------------------------------------------------
-    @Test(groups={"tck"})
+    @Test
     public void test_hashCode_floatingWeek_gap_notEndOfDay() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(a.hashCode(), b.hashCode());
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_hashCode_floatingWeek_overlap_endOfDay_nullDayOfWeek() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.OCTOBER, 20, null, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0300, OFFSET_0200);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
                 Month.OCTOBER, 20, null, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0300, OFFSET_0200);
         assertEquals(a.hashCode(), b.hashCode());
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_hashCode_floatingWeekBackwards() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(a.hashCode(), b.hashCode());
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_hashCode_fixedDate() {
         ZoneOffsetTransitionRule a = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         ZoneOffsetTransitionRule b = ZoneOffsetTransitionRule.of(

@@ -506,43 +506,43 @@
     }
 
     //-----------------------------------------------------------------------
     // toString()
     //-----------------------------------------------------------------------
-    @Test(groups={"tck"})
+    @Test
     public void test_toString_floatingWeek_gap_notEndOfDay() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, SUNDAY on or after MARCH 20 at 01:00 WALL, standard offset +02:00]");
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_toString_floatingWeek_overlap_endOfDay() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.OCTOBER, 20, DayOfWeek.SUNDAY, LocalTime.MIDNIGHT, true, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0300, OFFSET_0200);
         assertEquals(test.toString(), "TransitionRule[Overlap +03:00 to +02:00, SUNDAY on or after OCTOBER 20 at 24:00 WALL, standard offset +02:00]");
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_toString_floatingWeekBackwards_last() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -1, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         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]");
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_toString_floatingWeekBackwards_secondLast() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, -2, DayOfWeek.SUNDAY, TIME_0100, false, TimeDefinition.WALL,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         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]");
     }
 
-    @Test(groups={"tck"})
+    @Test
     public void test_toString_fixedDate() {
         ZoneOffsetTransitionRule test = ZoneOffsetTransitionRule.of(
                 Month.MARCH, 20, null, TIME_0100, false, TimeDefinition.STANDARD,
                 OFFSET_0200, OFFSET_0200, OFFSET_0300);
         assertEquals(test.toString(), "TransitionRule[Gap +02:00 to +03:00, MARCH 20 at 01:00 STANDARD, standard offset +02:00]");