1 /*
2 * Copyright (c) 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 */
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.format;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.fail;
64
65 import java.time.DateTimeException;
66 import java.time.Instant;
67 import java.time.OffsetDateTime;
68 import java.time.Period;
69 import java.time.ZoneOffset;
70 import java.time.format.DateTimeFormatter;
71 import java.time.format.DateTimeFormatterBuilder;
72 import java.time.format.ResolverStyle;
73 import java.time.temporal.TemporalAccessor;
74
75 import org.testng.annotations.DataProvider;
76 import org.testng.annotations.Test;
77
78 /**
79 * Test DateTimeFormatterBuilder.appendInstant().
80 */
81 @Test
82 public class TCKInstantPrinterParser {
83
84 @DataProvider(name="printGrouped")
85 Object[][] data_printGrouped() {
86 return new Object[][] {
87 {0, 0, "1970-01-01T00:00:00Z"},
88
89 {-1, 0, "1969-12-31T23:59:59Z"},
90 {1, 0, "1970-01-01T00:00:01Z"},
91 {60, 0, "1970-01-01T00:01:00Z"},
92 {3600, 0, "1970-01-01T01:00:00Z"},
93 {86400, 0, "1970-01-02T00:00:00Z"},
94
95 {182, 2, "1970-01-01T00:03:02.000000002Z"},
96 {182, 20, "1970-01-01T00:03:02.000000020Z"},
97 {182, 200, "1970-01-01T00:03:02.000000200Z"},
183 {9, Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
184 {9, Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
185 };
186 }
187
188 @Test(dataProvider="printDigits")
189 public void test_print_digits(int fractionalDigits, long instantSecs, int nano, String expected) {
190 Instant instant = Instant.ofEpochSecond(instantSecs, nano);
191 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(fractionalDigits).toFormatter();
192 assertEquals(f.format(instant), expected);
193 }
194
195 //-----------------------------------------------------------------------
196 @DataProvider(name="parseDigits")
197 Object[][] data_parse_digits() {
198 return new Object[][] {
199 {0, 0, "1970-01-01T00:00:00Z"},
200 {0, 0, "1970-01-01T00:00:00Z"},
201 {0, 0, "1970-01-01T00:00:00.0Z"},
202 {0, 0, "1970-01-01T00:00:00.000Z"},
203 {0, 0, "1970-01-01T00:00:00.000000000Z"},
204
205 {-1, 0, "1969-12-31T23:59:59Z"},
206 {1, 0, "1970-01-01T00:00:01Z"},
207 {60, 0, "1970-01-01T00:01:00Z"},
208 {3600, 0, "1970-01-01T01:00:00Z"},
209 {86400, 0, "1970-01-02T00:00:00Z"},
210
211 {182, 234000000, "1970-01-01T00:03:02.234Z"},
212 {182, 234000000, "1970-01-01T00:03:02.2340Z"},
213 {182, 234000000, "1970-01-01T00:03:02.23400Z"},
214 {182, 234000000, "1970-01-01T00:03:02.234000Z"},
215 {182, 234000000, "1970-01-01T00:03:02.234000000Z"},
216
217 {((23 * 60) + 59) * 60 + 59, 123456789, "1970-01-01T23:59:59.123456789Z"},
218
219 {Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
220 {Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
221 };
222 }
223
224 @Test(dataProvider="parseDigits")
225 public void test_parse_digitsMinusOne(long instantSecs, int nano, String input) {
226 Instant expected = Instant.ofEpochSecond(instantSecs, nano);
227 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
228 assertEquals(f.parse(input, Instant::from), expected);
229 assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
230 assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
231 }
232
233 @Test(dataProvider="parseDigits")
234 public void test_parse_digitsNine(long instantSecs, int nano, String input) {
235 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(9).toFormatter();
236 if (input.charAt(input.length() - 11) == '.') {
237 Instant expected = Instant.ofEpochSecond(instantSecs, nano);
238 assertEquals(f.parse(input, Instant::from), expected);
239 assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
240 assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
241 } else {
242 try {
243 f.parse(input, Instant::from);
244 fail();
245 } catch (DateTimeException ex) {
246 // expected
247 }
248 }
249 }
250
251 @Test
252 public void test_parse_endOfDay() {
253 Instant expected = OffsetDateTime.of(1970, 2, 4, 0, 0, 0, 0, ZoneOffset.UTC).toInstant();
254 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
255 for (ResolverStyle style : ResolverStyle.values()) {
256 TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T24:00:00Z");
257 assertEquals(parsed.query(Instant::from), expected);
258 assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
259 assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
260 }
261 }
262
263 @Test
264 public void test_parse_leapSecond() {
265 Instant expected = OffsetDateTime.of(1970, 2, 3, 23, 59, 59, 123456789, ZoneOffset.UTC).toInstant();
266 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
267 for (ResolverStyle style : ResolverStyle.values()) {
268 TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T23:59:60.123456789Z");
269 assertEquals(parsed.query(Instant::from), expected);
270 assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
271 assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.TRUE);
272 }
273 }
274
275 //-----------------------------------------------------------------------
276 @Test(expectedExceptions=IllegalArgumentException.class)
277 public void test_appendInstant_tooSmall() {
278 new DateTimeFormatterBuilder().appendInstant(-2);
279 }
280
281 @Test(expectedExceptions=IllegalArgumentException.class)
282 public void test_appendInstant_tooBig() {
283 new DateTimeFormatterBuilder().appendInstant(10);
284 }
285
286 }
|
1 /*
2 * Copyright (c) 2013, 2018, 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 */
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.format;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.fail;
64
65 import java.time.DateTimeException;
66 import java.time.Instant;
67 import java.time.OffsetDateTime;
68 import java.time.Period;
69 import java.time.ZoneOffset;
70 import java.time.format.DateTimeFormatter;
71 import java.time.format.DateTimeFormatterBuilder;
72 import java.time.format.DateTimeParseException;
73 import java.time.format.ResolverStyle;
74 import java.time.temporal.TemporalAccessor;
75
76 import org.testng.annotations.DataProvider;
77 import org.testng.annotations.Test;
78
79 /*
80 * @test
81 * @bug 8166138
82 */
83
84 /**
85 * Test DateTimeFormatterBuilder.appendInstant().
86 */
87 @Test
88 public class TCKInstantPrinterParser {
89
90 @DataProvider(name="printGrouped")
91 Object[][] data_printGrouped() {
92 return new Object[][] {
93 {0, 0, "1970-01-01T00:00:00Z"},
94
95 {-1, 0, "1969-12-31T23:59:59Z"},
96 {1, 0, "1970-01-01T00:00:01Z"},
97 {60, 0, "1970-01-01T00:01:00Z"},
98 {3600, 0, "1970-01-01T01:00:00Z"},
99 {86400, 0, "1970-01-02T00:00:00Z"},
100
101 {182, 2, "1970-01-01T00:03:02.000000002Z"},
102 {182, 20, "1970-01-01T00:03:02.000000020Z"},
103 {182, 200, "1970-01-01T00:03:02.000000200Z"},
189 {9, Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
190 {9, Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
191 };
192 }
193
194 @Test(dataProvider="printDigits")
195 public void test_print_digits(int fractionalDigits, long instantSecs, int nano, String expected) {
196 Instant instant = Instant.ofEpochSecond(instantSecs, nano);
197 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(fractionalDigits).toFormatter();
198 assertEquals(f.format(instant), expected);
199 }
200
201 //-----------------------------------------------------------------------
202 @DataProvider(name="parseDigits")
203 Object[][] data_parse_digits() {
204 return new Object[][] {
205 {0, 0, "1970-01-01T00:00:00Z"},
206 {0, 0, "1970-01-01T00:00:00Z"},
207 {0, 0, "1970-01-01T00:00:00.0Z"},
208 {0, 0, "1970-01-01T00:00:00.000Z"},
209
210 {0, 0, "1970-01-01T00:00:00+00:00"},
211 {0, 0, "1970-01-01T05:30:00+05:30"},
212 {0, 0, "1970-01-01T01:00:00.0+01:00"},
213
214 {-1, 0, "1969-12-31T23:59:59Z"},
215 {1, 0, "1970-01-01T00:00:01Z"},
216 {60, 0, "1970-01-01T00:01:00Z"},
217 {3600, 0, "1970-01-01T01:00:00Z"},
218 {86400, 0, "1970-01-02T00:00:00Z"},
219
220 {-1, 0, "1969-12-31T23:59:59+00:00"},
221 {1, 0, "1970-01-01T05:30:01+05:30"},
222 {60, 0, "1969-12-31T19:01:00-05:00"},
223 {3600, 0, "1970-01-01T06:30:00+05:30"},
224 {86400, 0, "1970-01-01T19:00:00-05:00"},
225
226 {182, 234000000, "1970-01-01T00:03:02.234Z"},
227 {182, 234000000, "1970-01-01T00:03:02.2340Z"},
228 {182, 234000000, "1970-01-01T00:03:02.23400Z"},
229 {182, 234000000, "1970-01-01T00:03:02.234000Z"},
230
231 {182, 234000000, "1970-01-01T00:03:02.234+00:00"},
232 {182, 234000000, "1970-01-01T05:33:02.2340+05:30"},
233 {182, 234000000, "1969-12-31T19:03:02.23400-05:00"},
234 {182, 234000000, "1970-01-01T00:03:02.234000+00:00"},
235
236 };
237 }
238
239 @Test(dataProvider="parseDigits")
240 public void test_parse_digitsMinusOne(long instantSecs, int nano, String input) {
241 Instant expected = Instant.ofEpochSecond(instantSecs, nano);
242 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
243 assertEquals(f.parse(input, Instant::from), expected);
244 assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
245 assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
246 }
247
248 @DataProvider(name="parseNineDigits")
249 Object[][] data_parse_ninedigits() {
250 return new Object[][] {
251 {0, 0, "1970-01-01T00:00:00.000000000Z"},
252 {0, 0, "1970-01-01T05:30:00.000000000+05:30"},
253
254 {182, 234000000, "1970-01-01T00:03:02.234000000Z"},
255 {182, 234000000, "1970-01-01T01:03:02.234000000+01:00"},
256
257 {((23 * 60) + 59) * 60 + 59, 123456789, "1970-01-01T23:59:59.123456789Z"},
258 {((23 * 60) + 59) * 60 + 59, 123456789, "1970-01-02T05:29:59.123456789+05:30"},
259
260 {Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999Z"},
261 {Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000Z"},
262 {Instant.MAX.getEpochSecond(), 999999999, "+1000000000-12-31T23:59:59.999999999+00:00"},
263 {Instant.MIN.getEpochSecond(), 0, "-1000000000-01-01T00:00:00.000000000+00:00"},
264 };
265 }
266
267 @Test(dataProvider="parseNineDigits")
268 public void test_parse_digitsNine(long instantSecs, int nano, String input) {
269 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(9).toFormatter();
270 Instant expected = Instant.ofEpochSecond(instantSecs, nano);
271 assertEquals(f.parse(input, Instant::from), expected);
272 assertEquals(f.parse(input).query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
273 assertEquals(f.parse(input).query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
274 }
275
276 @DataProvider(name="parseMaxMinInstant")
277 Object[][] data_parse_MaxMinInstant() {
278 return new Object[][] {
279 {"+1000000000-12-31T23:59:59.999999999-01:00"},
280 {"-1000000000-01-01T00:00:00.000000000+01:00"}
281 };
282 }
283
284 @Test(dataProvider="parseMaxMinInstant", expectedExceptions=DateTimeParseException.class)
285 public void test_invalid_Instant(String input) {
286 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
287 f.parse(input, Instant::from);
288 }
289
290 @Test
291 public void test_parse_endOfDay() {
292 Instant expected = OffsetDateTime.of(1970, 2, 4, 0, 0, 0, 0, ZoneOffset.UTC).toInstant();
293 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
294 for (ResolverStyle style : ResolverStyle.values()) {
295 TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T24:00:00Z");
296 assertEquals(parsed.query(Instant::from), expected);
297 assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
298 assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
299 }
300 }
301
302 @Test
303 public void test_parse_leapSecond() {
304 Instant expected = OffsetDateTime.of(1970, 2, 3, 23, 59, 59, 123456789, ZoneOffset.UTC).toInstant();
305 DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
306 for (ResolverStyle style : ResolverStyle.values()) {
307 TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T23:59:60.123456789Z");
308 assertEquals(parsed.query(Instant::from), expected);
309 assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
310 assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.TRUE);
311 }
312 }
313
314 //-----------------------------------------------------------------------
315 @Test(expectedExceptions=IllegalArgumentException.class)
316 public void test_appendInstant_tooSmall() {
317 new DateTimeFormatterBuilder().appendInstant(-2);
318 }
319
320 @Test(expectedExceptions=IllegalArgumentException.class)
321 public void test_appendInstant_tooBig() {
322 new DateTimeFormatterBuilder().appendInstant(10);
323 }
324
325 //------------------------------------------------------------------------
326 @Test
327 public void test_equality() {
328 Instant instant1 = Instant.parse("2018-09-12T22:15:51+05:30");
329 Instant instant2 = Instant.parse("2018-09-12T16:45:51Z");
330 assertEquals(instant2, instant1);
331 }
332
333 }
|