Home | History | Annotate | Download | only in internal 
      1 /*
      2  * Copyright 2018 The gRPC 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 io.grpc.internal;
     18 
     19 import static org.junit.Assert.assertFalse;
     20 import static org.junit.Assert.assertTrue;
     21 
     22 import java.util.concurrent.Executor;
     23 import java.util.concurrent.TimeUnit;
     24 import org.junit.Test;
     25 import org.junit.runner.RunWith;
     26 import org.junit.runners.JUnit4;
     27 
     28 /**
     29  * Tests for {@link Rescheduler}.
     30  */
     31 @RunWith(JUnit4.class)
     32 public class ReschedulerTest {
     33 
     34   private final Runner runner = new Runner();
     35   private final Exec exec = new Exec();
     36   private final FakeClock scheduler = new FakeClock();
     37   private final Rescheduler rescheduler = new Rescheduler(
     38       runner,
     39       exec,
     40       scheduler.getScheduledExecutorService(),
     41       scheduler.getStopwatchSupplier().get());
     42 
     43   @Test
     44   public void runs() {
     45     assertFalse(runner.ran);
     46     rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
     47     assertFalse(runner.ran);
     48 
     49     scheduler.forwardNanos(1);
     50 
     51     assertTrue(runner.ran);
     52   }
     53 
     54   @Test
     55   public void cancels() {
     56     assertFalse(runner.ran);
     57     rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
     58     assertFalse(runner.ran);
     59     rescheduler.cancel(/* permanent= */ false);
     60 
     61     scheduler.forwardNanos(1);
     62 
     63     assertFalse(runner.ran);
     64     assertTrue(exec.executed);
     65   }
     66 
     67   @Test
     68   public void cancelPermanently() {
     69     assertFalse(runner.ran);
     70     rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
     71     assertFalse(runner.ran);
     72     rescheduler.cancel(/* permanent= */ true);
     73 
     74     scheduler.forwardNanos(1);
     75 
     76     assertFalse(runner.ran);
     77     assertFalse(exec.executed);
     78   }
     79 
     80   @Test
     81   public void reschedules() {
     82     assertFalse(runner.ran);
     83     rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
     84     assertFalse(runner.ran);
     85     assertFalse(exec.executed);
     86     rescheduler.reschedule(50, TimeUnit.NANOSECONDS);
     87     assertFalse(runner.ran);
     88     assertFalse(exec.executed);
     89 
     90     scheduler.forwardNanos(1);
     91     assertFalse(runner.ran);
     92     assertTrue(exec.executed);
     93 
     94     scheduler.forwardNanos(50);
     95 
     96     assertTrue(runner.ran);
     97   }
     98 
     99   @Test
    100   public void reschedulesShortDelay() {
    101     assertFalse(runner.ran);
    102     rescheduler.reschedule(50, TimeUnit.NANOSECONDS);
    103     assertFalse(runner.ran);
    104     assertFalse(exec.executed);
    105     rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
    106     assertFalse(runner.ran);
    107     assertFalse(exec.executed);
    108 
    109     scheduler.forwardNanos(1);
    110     assertTrue(runner.ran);
    111     assertTrue(exec.executed);
    112   }
    113 
    114   private static final class Exec implements Executor {
    115     boolean executed;
    116 
    117     @Override
    118     public void execute(Runnable command) {
    119       executed = true;
    120 
    121       command.run();
    122     }
    123   }
    124 
    125   private static final class Runner implements Runnable {
    126     boolean ran;
    127 
    128     @Override
    129     public void run() {
    130       ran = true;
    131     }
    132   }
    133 }
    134