1 /*
   2  * Copyright (c) 2007, 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 6464365
  27  * @summary Test state transitions; check protected methods are called
  28  * @author Martin Buchholz
  29  */
  30 
  31 import java.util.*;
  32 import java.util.concurrent.*;
  33 import java.util.concurrent.atomic.*;
  34 
  35 public class Customized {
  36     static final AtomicLong doneCount = new AtomicLong(0);
  37     static final AtomicLong setCount = new AtomicLong(0);
  38     static final AtomicLong setExceptionCount = new AtomicLong(0);
  39 
  40     static void equal(long expected, AtomicLong actual) {
  41         equal(expected, actual.get());
  42     }
  43 
  44     static void equalCounts(long x, long y, long z) {
  45         equal(x, doneCount);
  46         equal(y, setCount);
  47         equal(z, setExceptionCount);
  48     }
  49 
  50     static class MyFutureTask<V> extends FutureTask<V> {
  51         MyFutureTask(Runnable r, V result) { super(r, result); }
  52         protected void done() {
  53             doneCount.getAndIncrement();
  54             super.done();
  55         }
  56         protected void set(V v) {
  57             setCount.getAndIncrement();
  58             super.set(v);
  59         }
  60         protected void setException(Throwable t) {
  61             setExceptionCount.getAndIncrement();
  62             super.setException(t);
  63         }
  64         public boolean runAndReset() {
  65             return super.runAndReset();
  66         }
  67     }
  68 
  69     static <V> void checkReady(final FutureTask<V> task) {
  70         check(! task.isDone());
  71         check(! task.isCancelled());
  72         THROWS(TimeoutException.class,
  73                new Fun(){void f() throws Throwable {
  74                        task.get(0L, TimeUnit.SECONDS); }});
  75     }
  76 
  77     static <V> void checkDone(final FutureTask<V> task) {
  78         try {
  79             check(task.isDone());
  80             check(! task.isCancelled());
  81             check(task.get() != null);
  82         } catch (Throwable t) { unexpected(t); }
  83     }
  84 
  85     static <V> void checkCancelled(final FutureTask<V> task) {
  86         check(task.isDone());
  87         check(task.isCancelled());
  88         THROWS(CancellationException.class,
  89            new Fun(){void f() throws Throwable {
  90                task.get(0L, TimeUnit.SECONDS); }},
  91            new Fun(){void f() throws Throwable {
  92                task.get(); }});
  93     }
  94 
  95     static <V> void checkThrew(final FutureTask<V> task) {
  96         check(task.isDone());
  97         check(! task.isCancelled());
  98         THROWS(ExecutionException.class,
  99            new Fun(){void f() throws Throwable {
 100                task.get(0L, TimeUnit.SECONDS); }},
 101            new Fun(){void f() throws Throwable {
 102                task.get(); }});
 103     }
 104 
 105     static <V> void cancel(FutureTask<V> task, boolean mayInterruptIfRunning) {
 106         task.cancel(mayInterruptIfRunning);
 107         checkCancelled(task);
 108     }
 109 
 110     static <V> void run(FutureTask<V> task) {
 111         boolean isCancelled = task.isCancelled();
 112         task.run();
 113         check(task.isDone());
 114         equal(isCancelled, task.isCancelled());
 115     }
 116 
 117     static void realMain(String[] args) throws Throwable {
 118         final Runnable nop = new Runnable() {
 119                 public void run() {}};
 120         final Runnable bad = new Runnable() {
 121                 public void run() { throw new Error(); }};
 122 
 123         try {
 124             final MyFutureTask<Long> task = new MyFutureTask<Long>(nop, 42L);
 125             checkReady(task);
 126             equalCounts(0,0,0);
 127             check(task.runAndReset());
 128             checkReady(task);
 129             equalCounts(0,0,0);
 130             run(task);
 131             checkDone(task);
 132             equalCounts(1,1,0);
 133             equal(42L, task.get());
 134             run(task);
 135             checkDone(task);
 136             equalCounts(1,1,0);
 137             equal(42L, task.get());
 138         } catch (Throwable t) { unexpected(t); }
 139 
 140         try {
 141             final MyFutureTask<Long> task = new MyFutureTask<Long>(nop, 42L);
 142             cancel(task, false);
 143             equalCounts(2,1,0);
 144             cancel(task, false);
 145             equalCounts(2,1,0);
 146             run(task);
 147             equalCounts(2,1,0);
 148             check(! task.runAndReset());
 149         } catch (Throwable t) { unexpected(t); }
 150 
 151         try {
 152             final MyFutureTask<Long> task = new MyFutureTask<Long>(bad, 42L);
 153             checkReady(task);
 154             run(task);
 155             checkThrew(task);
 156             equalCounts(3,1,1);
 157             run(task);
 158             equalCounts(3,1,1);
 159         } catch (Throwable t) { unexpected(t); }
 160 
 161         try {
 162             final MyFutureTask<Long> task = new MyFutureTask<Long>(nop, 42L);
 163             checkReady(task);
 164             task.set(99L);
 165             checkDone(task);
 166             equalCounts(4,2,1);
 167             run(task);
 168             equalCounts(4,2,1);
 169             task.setException(new Throwable());
 170             checkDone(task);
 171             equalCounts(4,2,2);
 172         } catch (Throwable t) { unexpected(t); }
 173 
 174         try {
 175             final MyFutureTask<Long> task = new MyFutureTask<Long>(nop, 42L);
 176             checkReady(task);
 177             task.setException(new Throwable());
 178             checkThrew(task);
 179             equalCounts(5,2,3);
 180             run(task);
 181             equalCounts(5,2,3);
 182             task.set(99L);
 183             checkThrew(task);
 184             equalCounts(5,3,3);
 185         } catch (Throwable t) { unexpected(t); }
 186 
 187         System.out.printf("doneCount=%d%n", doneCount.get());
 188         System.out.printf("setCount=%d%n", setCount.get());
 189         System.out.printf("setExceptionCount=%d%n", setExceptionCount.get());
 190     }
 191 
 192     //--------------------- Infrastructure ---------------------------
 193     static volatile int passed = 0, failed = 0;
 194     static void pass() {passed++;}
 195     static void fail() {failed++; Thread.dumpStack();}
 196     static void fail(String msg) {System.out.println(msg); fail();}
 197     static void unexpected(Throwable t) {failed++; t.printStackTrace();}
 198     static void check(boolean cond) {if (cond) pass(); else fail();}
 199     static void equal(Object x, Object y) {
 200         if (x == null ? y == null : x.equals(y)) pass();
 201         else fail(x + " not equal to " + y);}
 202     public static void main(String[] args) throws Throwable {
 203         try {realMain(args);} catch (Throwable t) {unexpected(t);}
 204         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
 205         if (failed > 0) throw new AssertionError("Some tests failed");}
 206     private static abstract class Fun {abstract void f() throws Throwable;}
 207     static void THROWS(Class<? extends Throwable> k, Fun... fs) {
 208         for (Fun f : fs)
 209             try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
 210             catch (Throwable t) {
 211                 if (k.isAssignableFrom(t.getClass())) pass();
 212                 else unexpected(t);}}
 213 }
--- EOF ---