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 test.java.time;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.assertFalse;
64 import static org.testng.Assert.assertNotNull;
65 import static org.testng.Assert.assertSame;
66 import static org.testng.Assert.assertTrue;
67
68 import java.lang.reflect.Field;
69 import java.lang.reflect.Modifier;
70 import java.time.DateTimeException;
71 import java.time.Instant;
72 import java.time.LocalDateTime;
73 import java.time.ZoneId;
74 import java.time.ZoneOffset;
75 import java.time.ZonedDateTime;
76 import java.time.format.TextStyle;
77 import java.time.zone.ZoneOffsetTransition;
78 import java.time.zone.ZoneRules;
79 import java.time.zone.ZoneRulesException;
80 import java.util.List;
81 import java.util.Locale;
82 import java.util.SimpleTimeZone;
83 import java.util.TimeZone;
84
85 import org.testng.annotations.DataProvider;
86 import org.testng.annotations.Test;
87
88 /**
89 * Test ZoneId.
90 */
91 @Test
92 public class TestZoneId extends AbstractTest {
93
94 private static final int OVERLAP = 2;
95 private static final int GAP = 0;
96
97 //-----------------------------------------------------------------------
98 // Basics
99 //-----------------------------------------------------------------------
100 public void test_immutable() {
101 // cannot use standard test as ZoneId is abstract
102 Class<ZoneId> cls = ZoneId.class;
103 assertTrue(Modifier.isPublic(cls.getModifiers()));
104 Field[] fields = cls.getDeclaredFields();
105 for (Field field : fields) {
106 if (Modifier.isStatic(field.getModifiers()) == false) {
107 assertTrue(Modifier.isPrivate(field.getModifiers()));
108 assertTrue(Modifier.isFinal(field.getModifiers()) ||
109 (Modifier.isVolatile(field.getModifiers()) && Modifier.isTransient(field.getModifiers())));
110 }
111 }
112 }
113
114 //-----------------------------------------------------------------------
115 // UTC
116 //-----------------------------------------------------------------------
117 public void test_constant_UTC() {
118 ZoneId test = ZoneOffset.UTC;
119 assertEquals(test.getId(), "Z");
120 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "Z");
121 assertEquals(test.getRules().isFixedOffset(), true);
122 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), ZoneOffset.UTC);
123 checkOffset(test.getRules(), createLDT(2008, 6, 30), ZoneOffset.UTC, 1);
124 assertSame(test, ZoneId.of("UTC+00"));
125 }
126
127 //-----------------------------------------------------------------------
128 // system default
129 //-----------------------------------------------------------------------
130 public void test_systemDefault() {
131 ZoneId test = ZoneId.systemDefault();
132 assertEquals(test.getId(), TimeZone.getDefault()
133 .getID()
134 .replaceAll("GMT|UTC|UT", "Z"));
135 }
136
137 @Test(expectedExceptions = DateTimeException.class)
138 public void test_systemDefault_unableToConvert_badFormat() {
139 TimeZone current = TimeZone.getDefault();
140 try {
141 TimeZone.setDefault(new SimpleTimeZone(127, "Something Weird"));
142 ZoneId.systemDefault();
143 } finally {
144 TimeZone.setDefault(current);
145 }
146 }
147
148 @Test(expectedExceptions = ZoneRulesException.class)
149 public void test_systemDefault_unableToConvert_unknownId() {
150 TimeZone current = TimeZone.getDefault();
151 try {
152 TimeZone.setDefault(new SimpleTimeZone(127, "SomethingWeird"));
153 ZoneId.systemDefault();
154 } finally {
155 TimeZone.setDefault(current);
156 }
157 }
158
159 //-----------------------------------------------------------------------
160 @DataProvider(name="String_Fixed")
161 Object[][] data_of_string_Fixed() {
162 return new Object[][] {
163 {"+0", "Z"},
164 {"+5", "+05:00"},
165 {"+01", "+01:00"},
166 {"+0100", "+01:00"},{"+01:00", "+01:00"},
167 {"+010000", "+01:00"},{"+01:00:00", "+01:00"},
168 {"+12", "+12:00"},
169 {"+1234", "+12:34"},{"+12:34", "+12:34"},
170 {"+123456", "+12:34:56"},{"+12:34:56", "+12:34:56"},
171 {"-02", "-02:00"},
172 {"-5", "-05:00"},
173 {"-0200", "-02:00"},{"-02:00", "-02:00"},
174 {"-020000", "-02:00"},{"-02:00:00", "-02:00"},
175 };
176 }
177
178 @Test(dataProvider="String_Fixed")
179 public void test_of_string_offset(String input, String id) {
180 ZoneId test = ZoneId.of(input);
181 assertEquals(test.getId(), id);
182 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), id);
183 assertEquals(test.getRules().isFixedOffset(), true);
184 ZoneOffset offset = ZoneOffset.of(id);
185 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset);
186 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1);
187 }
188
189 @Test(dataProvider="String_Fixed")
190 public void test_of_string_FixedUTC(String input, String id) {
191 ZoneId test = ZoneId.of("UTC" + input);
192 assertEquals(test.getId(), id);
193 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), id);
194 assertEquals(test.getRules().isFixedOffset(), true);
195 ZoneOffset offset = ZoneOffset.of(id);
196 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset);
197 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1);
198 }
199
200 @Test(dataProvider="String_Fixed")
201 public void test_of_string_FixedGMT(String input, String id) {
202 ZoneId test = ZoneId.of("GMT" + input);
203 assertEquals(test.getId(), id);
204 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), id);
205 assertEquals(test.getRules().isFixedOffset(), true);
206 ZoneOffset offset = ZoneOffset.of(id);
207 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset);
208 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1);
209 }
210
211 //-----------------------------------------------------------------------
212 // Europe/London
213 //-----------------------------------------------------------------------
214 public void test_London() {
215 ZoneId test = ZoneId.of("Europe/London");
216 assertEquals(test.getId(), "Europe/London");
217 assertEquals(test.getRules().isFixedOffset(), false);
218 }
219
220 public void test_London_getOffset() {
221 ZoneId test = ZoneId.of("Europe/London");
222 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
223 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
224 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
225 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
226 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
227 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
228 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
229 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
230 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
231 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
|
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 test.java.time;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.assertFalse;
64 import static org.testng.Assert.assertNotNull;
65 import static org.testng.Assert.assertTrue;
66
67 import java.lang.reflect.Field;
68 import java.lang.reflect.Modifier;
69 import java.time.DateTimeException;
70 import java.time.Instant;
71 import java.time.LocalDateTime;
72 import java.time.ZoneId;
73 import java.time.ZoneOffset;
74 import java.time.ZonedDateTime;
75 import java.time.format.TextStyle;
76 import java.time.zone.ZoneOffsetTransition;
77 import java.time.zone.ZoneRules;
78 import java.time.zone.ZoneRulesException;
79 import java.util.List;
80 import java.util.Locale;
81 import java.util.SimpleTimeZone;
82 import java.util.TimeZone;
83
84 import org.testng.annotations.Test;
85
86 /**
87 * Test ZoneId.
88 */
89 @Test
90 public class TestZoneId extends AbstractTest {
91
92 private static final int OVERLAP = 2;
93 private static final int GAP = 0;
94
95 //-----------------------------------------------------------------------
96 // Basics
97 //-----------------------------------------------------------------------
98 public void test_immutable() {
99 // cannot use standard test as ZoneId is abstract
100 Class<ZoneId> cls = ZoneId.class;
101 assertTrue(Modifier.isPublic(cls.getModifiers()));
102 Field[] fields = cls.getDeclaredFields();
103 for (Field field : fields) {
104 if (Modifier.isStatic(field.getModifiers()) == false) {
105 assertTrue(Modifier.isPrivate(field.getModifiers()));
106 assertTrue(Modifier.isFinal(field.getModifiers()) ||
107 (Modifier.isVolatile(field.getModifiers()) && Modifier.isTransient(field.getModifiers())));
108 }
109 }
110 }
111
112 //-----------------------------------------------------------------------
113 // UTC
114 //-----------------------------------------------------------------------
115 public void test_constant_UTC() {
116 ZoneId test = ZoneOffset.UTC;
117 assertEquals(test.getId(), "Z");
118 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "Z");
119 assertEquals(test.getRules().isFixedOffset(), true);
120 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), ZoneOffset.UTC);
121 checkOffset(test.getRules(), createLDT(2008, 6, 30), ZoneOffset.UTC, 1);
122 }
123
124 //-----------------------------------------------------------------------
125 // system default
126 //-----------------------------------------------------------------------
127 public void test_systemDefault() {
128 ZoneId test = ZoneId.systemDefault();
129 assertEquals(test.getId(), TimeZone.getDefault().getID());
130 }
131
132 @Test(expectedExceptions = DateTimeException.class)
133 public void test_systemDefault_unableToConvert_badFormat() {
134 TimeZone current = TimeZone.getDefault();
135 try {
136 TimeZone.setDefault(new SimpleTimeZone(127, "Something Weird"));
137 ZoneId.systemDefault();
138 } finally {
139 TimeZone.setDefault(current);
140 }
141 }
142
143 @Test(expectedExceptions = ZoneRulesException.class)
144 public void test_systemDefault_unableToConvert_unknownId() {
145 TimeZone current = TimeZone.getDefault();
146 try {
147 TimeZone.setDefault(new SimpleTimeZone(127, "SomethingWeird"));
148 ZoneId.systemDefault();
149 } finally {
150 TimeZone.setDefault(current);
151 }
152 }
153
154 //-----------------------------------------------------------------------
155 // Europe/London
156 //-----------------------------------------------------------------------
157 public void test_London() {
158 ZoneId test = ZoneId.of("Europe/London");
159 assertEquals(test.getId(), "Europe/London");
160 assertEquals(test.getRules().isFixedOffset(), false);
161 }
162
163 public void test_London_getOffset() {
164 ZoneId test = ZoneId.of("Europe/London");
165 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
166 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
167 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
168 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
169 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
170 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
171 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
172 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
173 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
174 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
|