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) 2008-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;
  61 
  62 import static org.testng.Assert.assertEquals;
  63 import static org.testng.Assert.assertSame;
  64 
  65 import java.io.IOException;
  66 import java.time.Clock;
  67 import java.time.Duration;
  68 import java.time.Instant;
  69 import java.time.LocalDateTime;
  70 import java.time.ZoneId;
  71 import java.time.ZoneOffset;
  72 import java.time.ZonedDateTime;
  73 
  74 import org.testng.annotations.Test;
  75 
  76 /**
  77  * Test tick clock.
  78  */
  79 @Test
  80 public class TCKClock_Tick extends AbstractTCKTest {
  81 
  82     private static final ZoneId MOSCOW = ZoneId.of("Europe/Moscow");
  83     private static final ZoneId PARIS = ZoneId.of("Europe/Paris");
  84     private static final Duration AMOUNT = Duration.ofSeconds(2);
  85     private static final ZonedDateTime ZDT = LocalDateTime.of(2008, 6, 30, 11, 30, 10, 500).atZone(ZoneOffset.ofHours(2));
  86     private static final Instant INSTANT = ZDT.toInstant();
  87 
  88     //-----------------------------------------------------------------------
  89     public void test_isSerializable() throws IOException, ClassNotFoundException {
  90         assertSerializable(Clock.tickSeconds(PARIS));
  91         assertSerializable(Clock.tickMinutes(MOSCOW));
  92         assertSerializable(Clock.tick(Clock.fixed(INSTANT, PARIS), AMOUNT));
  93     }
  94 
  95     //-----------------------------------------------------------------------
  96     public void test_tick_ClockDuration_250millis() {
  97         for (int i = 0; i < 1000; i++) {
  98             Clock test = Clock.tick(Clock.fixed(ZDT.withNano(i * 1000_000).toInstant(), PARIS), Duration.ofMillis(250));
  99             assertEquals(test.instant(), ZDT.withNano((i / 250) * 250_000_000).toInstant());
 100             assertEquals(test.getZone(), PARIS);
 101         }
 102     }
 103 
 104     public void test_tick_ClockDuration_250micros() {
 105         for (int i = 0; i < 1000; i++) {
 106             Clock test = Clock.tick(Clock.fixed(ZDT.withNano(i * 1000).toInstant(), PARIS), Duration.ofNanos(250_000));
 107             assertEquals(test.instant(), ZDT.withNano((i / 250) * 250_000).toInstant());
 108             assertEquals(test.getZone(), PARIS);
 109         }
 110     }
 111 
 112     public void test_tick_ClockDuration_20nanos() {
 113         for (int i = 0; i < 1000; i++) {
 114             Clock test = Clock.tick(Clock.fixed(ZDT.withNano(i).toInstant(), PARIS), Duration.ofNanos(20));
 115             assertEquals(test.instant(), ZDT.withNano((i / 20) * 20).toInstant());
 116             assertEquals(test.getZone(), PARIS);
 117         }
 118     }
 119 
 120     public void test_tick_ClockDuration_zeroDuration() {
 121         Clock underlying = Clock.system(PARIS);
 122         Clock test = Clock.tick(underlying, Duration.ZERO);
 123         assertSame(test, underlying);  // spec says same
 124     }
 125 
 126     public void test_tick_ClockDuration_1nsDuration() {
 127         Clock underlying = Clock.system(PARIS);
 128         Clock test = Clock.tick(underlying, Duration.ofNanos(1));
 129         assertSame(test, underlying);  // spec says same
 130     }
 131 
 132     @Test(expectedExceptions = ArithmeticException.class)
 133     public void test_tick_ClockDuration_maxDuration() {
 134         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(Long.MAX_VALUE));
 135     }
 136 
 137     @Test(expectedExceptions = IllegalArgumentException.class)
 138     public void test_tick_ClockDuration_subMilliNotDivisible_123ns() {
 139         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(0, 123));
 140     }
 141 
 142     @Test(expectedExceptions = IllegalArgumentException.class)
 143     public void test_tick_ClockDuration_subMilliNotDivisible_999ns() {
 144         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(0, 999));
 145     }
 146 
 147     @Test(expectedExceptions = IllegalArgumentException.class)
 148     public void test_tick_ClockDuration_subMilliNotDivisible_999_999_999ns() {
 149         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(0, 999_999_999));
 150     }
 151 
 152     @Test(expectedExceptions = IllegalArgumentException.class)
 153     public void test_tick_ClockDuration_negative1ns() {
 154         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(0, -1));
 155     }
 156 
 157     @Test(expectedExceptions = IllegalArgumentException.class)
 158     public void test_tick_ClockDuration_negative1s() {
 159         Clock.tick(Clock.systemUTC(), Duration.ofSeconds(-1));
 160     }
 161 
 162     @Test(expectedExceptions = NullPointerException.class)
 163     public void test_tick_ClockDuration_nullClock() {
 164         Clock.tick(null, Duration.ZERO);
 165     }
 166 
 167     @Test(expectedExceptions = NullPointerException.class)
 168     public void test_tick_ClockDuration_nullDuration() {
 169         Clock.tick(Clock.systemUTC(), null);
 170     }
 171 
 172     //-----------------------------------------------------------------------
 173     public void test_tickSeconds_ZoneId() throws Exception {
 174         Clock test = Clock.tickSeconds(PARIS);
 175         assertEquals(test.getZone(), PARIS);
 176         assertEquals(test.instant().getNano(), 0);
 177         Thread.sleep(100);
 178         assertEquals(test.instant().getNano(), 0);
 179     }
 180 
 181     @Test(expectedExceptions = NullPointerException.class)
 182     public void test_tickSeconds_ZoneId_nullZoneId() {
 183         Clock.tickSeconds(null);
 184     }
 185 
 186     //-----------------------------------------------------------------------
 187     public void test_tickMinutes_ZoneId() {
 188         Clock test = Clock.tickMinutes(PARIS);
 189         assertEquals(test.getZone(), PARIS);
 190         Instant instant = test.instant();
 191         assertEquals(instant.getEpochSecond() % 60, 0);
 192         assertEquals(instant.getNano(), 0);
 193     }
 194 
 195     @Test(expectedExceptions = NullPointerException.class)
 196     public void test_tickMinutes_ZoneId_nullZoneId() {
 197         Clock.tickMinutes(null);
 198     }
 199 
 200     //-------------------------------------------------------------------------
 201     public void test_withZone() {
 202         Clock test = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 203         Clock changed = test.withZone(MOSCOW);
 204         assertEquals(test.getZone(), PARIS);
 205         assertEquals(changed.getZone(), MOSCOW);
 206     }
 207 
 208     public void test_withZone_equal() {
 209         Clock test = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 210         Clock changed = test.withZone(PARIS);
 211         assertEquals(test, changed);
 212     }
 213 
 214     @Test(expectedExceptions = NullPointerException.class)
 215     public void test_withZone_null() {
 216         Clock.tick(Clock.system(PARIS), Duration.ofMillis(500)).withZone(null);
 217     }
 218 
 219     //-----------------------------------------------------------------------
 220     public void test__equals() {
 221         Clock a = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 222         Clock b = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 223         assertEquals(a.equals(a), true);
 224         assertEquals(a.equals(b), true);
 225         assertEquals(b.equals(a), true);
 226         assertEquals(b.equals(b), true);
 227 
 228         Clock c = Clock.tick(Clock.system(MOSCOW), Duration.ofMillis(500));
 229         assertEquals(a.equals(c), false);
 230 
 231         Clock d = Clock.tick(Clock.system(PARIS), Duration.ofMillis(499));
 232         assertEquals(a.equals(d), false);
 233 
 234         assertEquals(a.equals(null), false);
 235         assertEquals(a.equals("other type"), false);
 236         assertEquals(a.equals(Clock.systemUTC()), false);
 237     }
 238 
 239     public void test_hashCode() {
 240         Clock a = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 241         Clock b = Clock.tick(Clock.system(PARIS), Duration.ofMillis(500));
 242         assertEquals(a.hashCode(), a.hashCode());
 243         assertEquals(a.hashCode(), b.hashCode());
 244 
 245         Clock c = Clock.tick(Clock.system(MOSCOW), Duration.ofMillis(500));
 246         assertEquals(a.hashCode() == c.hashCode(), false);
 247 
 248         Clock d = Clock.tick(Clock.system(PARIS), Duration.ofMillis(499));
 249         assertEquals(a.hashCode() == d.hashCode(), false);
 250     }
 251 }