Home | History | Annotate | Download | only in concurrent 
      1 /*
      2  * Copyright (C) 2006 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.util.concurrent;
     18 
     19 import junit.framework.TestCase;
     20 
     21 import java.util.concurrent.Callable;
     22 import java.util.concurrent.ExecutorService;
     23 import java.util.concurrent.Executors;
     24 import java.util.concurrent.TimeUnit;
     25 
     26 /**
     27  * Unit test for {@link SimpleTimeLimiter}.
     28  *
     29  * @author kevinb
     30  */
     31 public class SimpleTimeLimiterTest extends TestCase {
     32 
     33   private static final int DELAY_MS = 50;
     34   private static final int ENOUGH_MS = 500;
     35   private static final int NOT_ENOUGH_MS = 5;
     36 
     37   private TimeLimiter service;
     38 
     39   private static final ExecutorService executor
     40       = Executors.newFixedThreadPool(1);
     41 
     42   private static String someGoodStaticMethod() throws InterruptedException {
     43     TimeUnit.MILLISECONDS.sleep(DELAY_MS);
     44     return "yes";
     45   }
     46 
     47   private static String someBadStaticMethod() throws InterruptedException,
     48       SampleException {
     49     TimeUnit.MILLISECONDS.sleep(DELAY_MS);
     50     throw new SampleException();
     51   }
     52 
     53   @Override protected void setUp() throws Exception {
     54     super.setUp();
     55     service = new SimpleTimeLimiter(executor);
     56   }
     57 
     58   public void testGoodCallableWithEnoughTime() throws Exception {
     59     long start = System.nanoTime();
     60     String result = service.callWithTimeout(
     61         new Callable<String>() {
     62           @Override
     63           public String call() throws InterruptedException {
     64             return someGoodStaticMethod();
     65           }
     66         }, ENOUGH_MS, TimeUnit.MILLISECONDS, true);
     67     assertEquals("yes", result);
     68     assertTheCallTookBetween(start, DELAY_MS, ENOUGH_MS);
     69   }
     70 
     71   public void testGoodCallableWithNotEnoughTime() throws Exception {
     72     long start = System.nanoTime();
     73     try {
     74       service.callWithTimeout(
     75           new Callable<String>() {
     76             @Override
     77             public String call() throws InterruptedException {
     78               return someGoodStaticMethod();
     79             }
     80           }, NOT_ENOUGH_MS, TimeUnit.MILLISECONDS, true);
     81       fail("no exception thrown");
     82     } catch (UncheckedTimeoutException expected) {
     83     }
     84     assertTheCallTookBetween(start, NOT_ENOUGH_MS, DELAY_MS);
     85   }
     86 
     87   public void testBadCallableWithEnoughTime() throws Exception {
     88     long start = System.nanoTime();
     89     try {
     90       service.callWithTimeout(
     91           new Callable<String>() {
     92             @Override
     93             public String call() throws SampleException, InterruptedException {
     94               return someBadStaticMethod();
     95             }
     96           }, ENOUGH_MS, TimeUnit.MILLISECONDS, true);
     97       fail("no exception thrown");
     98     } catch (SampleException expected) {
     99     }
    100     assertTheCallTookBetween(start, DELAY_MS, ENOUGH_MS);
    101   }
    102 
    103   public void testBadCallableWithNotEnoughTime() throws Exception {
    104     long start = System.nanoTime();
    105     try {
    106       service.callWithTimeout(
    107           new Callable<String>() {
    108             @Override
    109             public String call() throws SampleException, InterruptedException {
    110               return someBadStaticMethod();
    111             }
    112           }, NOT_ENOUGH_MS, TimeUnit.MILLISECONDS, true);
    113       fail("no exception thrown");
    114     } catch (UncheckedTimeoutException expected) {
    115     }
    116     assertTheCallTookBetween(start, NOT_ENOUGH_MS, DELAY_MS);
    117   }
    118 
    119   public void testGoodMethodWithEnoughTime() throws Exception {
    120     SampleImpl target = new SampleImpl();
    121     Sample proxy = service.newProxy(
    122         target, Sample.class, ENOUGH_MS, TimeUnit.MILLISECONDS);
    123     long start = System.nanoTime();
    124     assertEquals("x", proxy.sleepThenReturnInput("x"));
    125     assertTheCallTookBetween(start, DELAY_MS, ENOUGH_MS);
    126     assertTrue(target.finished);
    127   }
    128 
    129   public void testGoodMethodWithNotEnoughTime() throws Exception {
    130     SampleImpl target = new SampleImpl();
    131     Sample proxy = service.newProxy(
    132         target, Sample.class, NOT_ENOUGH_MS, TimeUnit.MILLISECONDS);
    133     long start = System.nanoTime();
    134     try {
    135       proxy.sleepThenReturnInput("x");
    136       fail("no exception thrown");
    137     } catch (UncheckedTimeoutException expected) {
    138     }
    139     assertTheCallTookBetween(start, NOT_ENOUGH_MS, DELAY_MS);
    140 
    141     // Is it still computing away anyway?
    142     assertFalse(target.finished);
    143     TimeUnit.MILLISECONDS.sleep(ENOUGH_MS);
    144     assertFalse(target.finished);
    145   }
    146 
    147   public void testBadMethodWithEnoughTime() throws Exception {
    148     SampleImpl target = new SampleImpl();
    149     Sample proxy = service.newProxy(
    150         target, Sample.class, ENOUGH_MS, TimeUnit.MILLISECONDS);
    151     long start = System.nanoTime();
    152     try {
    153       proxy.sleepThenThrowException();
    154       fail("no exception thrown");
    155     } catch (SampleException expected) {
    156     }
    157     assertTheCallTookBetween(start, DELAY_MS, ENOUGH_MS);
    158   }
    159 
    160   public void testBadMethodWithNotEnoughTime() throws Exception {
    161     SampleImpl target = new SampleImpl();
    162     Sample proxy = service.newProxy(
    163         target, Sample.class, NOT_ENOUGH_MS, TimeUnit.MILLISECONDS);
    164     long start = System.nanoTime();
    165     try {
    166       proxy.sleepThenThrowException();
    167       fail("no exception thrown");
    168     } catch (UncheckedTimeoutException expected) {
    169     }
    170     assertTheCallTookBetween(start, NOT_ENOUGH_MS, DELAY_MS);
    171   }
    172 
    173   private static void assertTheCallTookBetween(
    174       long startNanos, int atLeastMillis, int atMostMillis) {
    175     long nanos = System.nanoTime() - startNanos;
    176     assertTrue(nanos >= atLeastMillis * 1000000);
    177     assertTrue(nanos <= atMostMillis * 1000000);
    178   }
    179 
    180   public interface Sample {
    181     String sleepThenReturnInput(String input);
    182     void sleepThenThrowException() throws SampleException;
    183   }
    184 
    185   @SuppressWarnings("serial")
    186   public static class SampleException extends Exception {}
    187 
    188   public static class SampleImpl implements Sample {
    189     boolean finished;
    190 
    191     @Override
    192     public String sleepThenReturnInput(String input) {
    193       try {
    194         TimeUnit.MILLISECONDS.sleep(DELAY_MS);
    195         finished = true;
    196         return input;
    197       } catch (InterruptedException e) {
    198         return null;
    199       }
    200     }
    201     @Override
    202     public void sleepThenThrowException() throws SampleException {
    203       try {
    204         TimeUnit.MILLISECONDS.sleep(DELAY_MS);
    205       } catch (InterruptedException e) {
    206       }
    207       throw new SampleException();
    208     }
    209   }
    210 }
    211