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  */
  23 
  24 /*
  25  *@test
  26  *@bug 8007520 8008254
  27  *@summary Test those bridge methods to/from java.time date/time classes
  28  */
  29 
  30 import java.util.Calendar;
  31 import java.util.Date;
  32 import java.util.GregorianCalendar;
  33 import java.util.Random;
  34 import java.util.TimeZone;
  35 import java.time.Instant;
  36 import java.time.LocalDateTime;
  37 import java.time.ZonedDateTime;
  38 import java.time.ZoneId;
  39 import java.time.ZoneOffset;
  40 
  41 public class JavatimeTest {
  42 
  43     static final int NANOS_PER_SECOND = 1000_000_000;
  44 
  45     public static void main(String[] args) throws Throwable {
  46 
  47         int N = 10000;
  48         long t1970 = new java.util.Date(70, 0, 01).getTime();
  49         Random r = new Random();
  50         for (int i = 0; i < N; i++) {
  51             int days  = r.nextInt(50) * 365 + r.nextInt(365);
  52             long secs = t1970 + days * 86400 + r.nextInt(86400);
  53             int nanos = r.nextInt(NANOS_PER_SECOND);
  54             int nanos_ms = nanos / 1000000 * 1000000; // millis precision
  55             long millis = secs * 1000 + r.nextInt(1000);
  56             LocalDateTime ldt = LocalDateTime.ofEpochSecond(secs, nanos, ZoneOffset.UTC);
  57             LocalDateTime ldt_ms = LocalDateTime.ofEpochSecond(secs, nanos_ms, ZoneOffset.UTC);
  58             Instant inst = Instant.ofEpochSecond(secs, nanos);
  59             Instant inst_ms = Instant.ofEpochSecond(secs, nanos_ms);
  60             ///////////// java.util.Date /////////////////////////
  61             Date jud = new java.util.Date(millis);
  62             Instant inst0 = jud.toInstant();
  63             if (jud.getTime() != inst0.toEpochMilli() ||
  64                 !jud.equals(Date.from(inst0))) {
  65                 System.out.printf("ms: %16d  ns: %10d  ldt:[%s]%n", millis, nanos, ldt);
  66                 throw new RuntimeException("FAILED: j.u.d -> instant -> j.u.d");
  67             }
  68             // roundtrip only with millis precision
  69             Date jud0 = Date.from(inst_ms);
  70             if (jud0.getTime() != inst_ms.toEpochMilli() ||
  71                 !inst_ms.equals(jud0.toInstant())) {
  72                 System.out.printf("ms: %16d  ns: %10d  ldt:[%s]%n", millis, nanos, ldt);
  73                 throw new RuntimeException("FAILED: instant -> j.u.d -> instant");
  74             }
  75             //////////// java.util.GregorianCalendar /////////////
  76             GregorianCalendar cal = new GregorianCalendar();
  77             // non-roundtrip of tz name between j.u.tz and j.t.zid
  78             cal.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
  79             cal.setGregorianChange(new java.util.Date(Long.MIN_VALUE));
  80             cal.setFirstDayOfWeek(Calendar.MONDAY);
  81             cal.setMinimalDaysInFirstWeek(4);
  82             cal.setTimeInMillis(millis);
  83             ZonedDateTime zdt0 = cal.toZonedDateTime();
  84             if (cal.getTimeInMillis() != zdt0.toInstant().toEpochMilli() ||
  85                 !cal.equals(GregorianCalendar.from(zdt0))) {
  86                 System.out.println("cal:" + cal);
  87                 System.out.println("zdt:" + zdt0);
  88                 System.out.println("calNew:" + GregorianCalendar.from(zdt0));
  89                 System.out.printf("ms: %16d  ns: %10d  ldt:[%s]%n", millis, nanos, ldt);
  90                 throw new RuntimeException("FAILED: gcal -> zdt -> gcal");
  91             }
  92             inst0 = cal.toInstant();
  93             if (cal.getTimeInMillis() != inst0.toEpochMilli()) {
  94                 System.out.printf("ms: %16d  ns: %10d  ldt:[%s]%n", millis, nanos, ldt);
  95                 throw new RuntimeException("FAILED: gcal -> zdt");
  96             }
  97             ZonedDateTime zdt = ZonedDateTime.of(ldt_ms, ZoneId.systemDefault());
  98             GregorianCalendar cal0 = GregorianCalendar.from(zdt);
  99             if (zdt.toInstant().toEpochMilli() != cal0.getTimeInMillis() ||
 100                 !zdt.equals(GregorianCalendar.from(zdt).toZonedDateTime())) {
 101                 System.out.printf("ms: %16d  ns: %10d  ldt:[%s]%n", millis, nanos, ldt);
 102                 throw new RuntimeException("FAILED: zdt -> gcal -> zdt");
 103             }
 104         }
 105 
 106         ///////////// java.util.TimeZone /////////////////////////
 107         for (String zidStr : TimeZone.getAvailableIDs()) {
 108             // TBD: tzdt intergration
 109             if (zidStr.startsWith("SystemV") ||
 110                 zidStr.contains("Riyadh8") ||
 111                 zidStr.equals("US/Pacific-New") ||
 112                 zidStr.equals("EST") ||
 113                 zidStr.equals("HST") ||
 114                 zidStr.equals("MST")) {
 115                 continue;
 116             }
 117             ZoneId zid = ZoneId.of(zidStr, ZoneId.SHORT_IDS);
 118             if (!zid.equals(TimeZone.getTimeZone(zid).toZoneId())) {
 119                 throw new RuntimeException("FAILED: zid -> tz -> zid :" + zidStr);
 120             }
 121             TimeZone tz = TimeZone.getTimeZone(zidStr);
 122             // no round-trip for alias and "GMT"
 123             if (!tz.equals(TimeZone.getTimeZone(tz.toZoneId())) &&
 124                 !ZoneId.SHORT_IDS.containsKey(zidStr) &&
 125                 !zidStr.startsWith("GMT")) {
 126                 throw new RuntimeException("FAILED: tz -> zid -> tz :" + zidStr);
 127             }
 128         }
 129         System.out.println("Passed!");
 130     }
 131 }