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 abstract static 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 }