1 /* 2 * Copyright (C) 2008 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.testing; 18 19 import com.google.common.annotations.GwtCompatible; 20 import com.google.common.annotations.GwtIncompatible; 21 22 import junit.framework.TestCase; 23 24 import java.util.EnumSet; 25 import java.util.concurrent.Callable; 26 import java.util.concurrent.CountDownLatch; 27 import java.util.concurrent.ExecutorService; 28 import java.util.concurrent.Executors; 29 import java.util.concurrent.TimeUnit; 30 31 /** 32 * Unit test for {@link FakeTicker}. 33 * 34 * @author Jige Yu 35 */ 36 @GwtCompatible(emulated = true) 37 public class FakeTickerTest extends TestCase { 38 39 @GwtIncompatible("NullPointerTester") testNullPointerExceptions()40 public void testNullPointerExceptions() { 41 NullPointerTester tester = new NullPointerTester(); 42 tester.testAllPublicInstanceMethods(new FakeTicker()); 43 } 44 testAdvance()45 public void testAdvance() { 46 FakeTicker ticker = new FakeTicker(); 47 assertEquals(0, ticker.read()); 48 assertSame(ticker, ticker.advance(10)); 49 assertEquals(10, ticker.read()); 50 ticker.advance(1, TimeUnit.MILLISECONDS); 51 assertEquals(1000010L, ticker.read()); 52 } 53 testAutoIncrementStep_returnsSameInstance()54 public void testAutoIncrementStep_returnsSameInstance() { 55 FakeTicker ticker = new FakeTicker(); 56 assertSame(ticker, ticker.setAutoIncrementStep(10, TimeUnit.NANOSECONDS)); 57 } 58 testAutoIncrementStep_nanos()59 public void testAutoIncrementStep_nanos() { 60 FakeTicker ticker = new FakeTicker().setAutoIncrementStep(10, TimeUnit.NANOSECONDS); 61 assertEquals(0, ticker.read()); 62 assertEquals(10, ticker.read()); 63 assertEquals(20, ticker.read()); 64 } 65 testAutoIncrementStep_millis()66 public void testAutoIncrementStep_millis() { 67 FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, TimeUnit.MILLISECONDS); 68 assertEquals(0, ticker.read()); 69 assertEquals(1000000, ticker.read()); 70 assertEquals(2000000, ticker.read()); 71 } 72 testAutoIncrementStep_seconds()73 public void testAutoIncrementStep_seconds() { 74 FakeTicker ticker = new FakeTicker().setAutoIncrementStep(3, TimeUnit.SECONDS); 75 assertEquals(0, ticker.read()); 76 assertEquals(3000000000L, ticker.read()); 77 assertEquals(6000000000L, ticker.read()); 78 } 79 testAutoIncrementStep_resetToZero()80 public void testAutoIncrementStep_resetToZero() { 81 FakeTicker ticker = new FakeTicker().setAutoIncrementStep(10, TimeUnit.NANOSECONDS); 82 assertEquals(0, ticker.read()); 83 assertEquals(10, ticker.read()); 84 assertEquals(20, ticker.read()); 85 86 for (TimeUnit timeUnit : EnumSet.allOf(TimeUnit.class)) { 87 ticker.setAutoIncrementStep(0, timeUnit); 88 assertEquals( 89 "Expected no auto-increment when setting autoIncrementStep to 0 " + timeUnit, 90 30, ticker.read()); 91 } 92 } 93 testAutoIncrement_negative()94 public void testAutoIncrement_negative() { 95 FakeTicker ticker = new FakeTicker(); 96 try { 97 ticker.setAutoIncrementStep(-1, TimeUnit.NANOSECONDS); 98 fail("Expected IllegalArgumentException"); 99 } catch (IllegalArgumentException expected) { 100 } 101 } 102 103 @GwtIncompatible("concurrency") 104 testConcurrentAdvance()105 public void testConcurrentAdvance() throws Exception { 106 final FakeTicker ticker = new FakeTicker(); 107 108 int numberOfThreads = 64; 109 runConcurrentTest(numberOfThreads, 110 new Callable<Void>() { 111 @Override 112 public Void call() throws Exception { 113 // adds two nanoseconds to the ticker 114 ticker.advance(1L); 115 Thread.sleep(10); 116 ticker.advance(1L); 117 return null; 118 } 119 }); 120 121 assertEquals(numberOfThreads * 2, ticker.read()); 122 } 123 124 @GwtIncompatible("concurrency") 125 testConcurrentAutoIncrementStep()126 public void testConcurrentAutoIncrementStep() throws Exception { 127 int incrementByNanos = 3; 128 final FakeTicker ticker = 129 new FakeTicker().setAutoIncrementStep(incrementByNanos, TimeUnit.NANOSECONDS); 130 131 int numberOfThreads = 64; 132 runConcurrentTest(numberOfThreads, 133 new Callable<Void>() { 134 @Override 135 public Void call() throws Exception { 136 ticker.read(); 137 return null; 138 } 139 }); 140 141 assertEquals(incrementByNanos * numberOfThreads, ticker.read()); 142 } 143 144 /** 145 * Runs {@code callable} concurrently {@code numberOfThreads} times. 146 */ 147 @GwtIncompatible("concurrency") runConcurrentTest(int numberOfThreads, final Callable<Void> callable)148 private void runConcurrentTest(int numberOfThreads, final Callable<Void> callable) 149 throws Exception { 150 ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads); 151 final CountDownLatch startLatch = new CountDownLatch(numberOfThreads); 152 final CountDownLatch doneLatch = new CountDownLatch(numberOfThreads); 153 for (int i = numberOfThreads; i > 0; i--) { 154 executorService.submit(new Callable<Void>() { 155 @Override 156 public Void call() throws Exception { 157 startLatch.countDown(); 158 startLatch.await(); 159 callable.call(); 160 doneLatch.countDown(); 161 return null; 162 } 163 }); 164 } 165 doneLatch.await(); 166 } 167 } 168