/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 6979009
* @summary Ensure ClosedByInterruptException is thrown when I/O operation
* interrupted by Thread.interrupt
*/
public class ClosedByInterrupt {
static final int K = 1024;
static volatile boolean failed;
f.deleteOnExit();
// create 1MB file.
byte[] b = new byte[K*K];
while (bb.hasRemaining())
}
// test with 1-16 concurrent threads
for (int i=1; i<=16; i++) {
test(f, i);
if (failed)
break;
}
if (failed)
throw new RuntimeException("Test failed");
}
/**
* Starts "nThreads" that do I/O on the given file concurrently. Continuously
* interrupts one of the threads to cause the file to be closed and
* ClosedByInterruptException to be thrown. The other threads should "fail" with
* ClosedChannelException (or the more specific AsynchronousCloseException).
*/
// start threads
for (int i=0; i<nThreads; i++) {
boolean interruptible = (i==0);
t.start();
threads[i] = t;
}
// give time for threads to start
// interrupt thread until channel is closed
}
// wait for test to finish
for (int i=0; i<nThreads; i++) {
}
}
}
/**
* A task that continuously reads or writes to random areas of a file
* until the channel is closed. An "interruptible" task expects the
* channel to be closed by an interupt, a "non-interruptible" thread
* does not.
*/
final boolean interruptible;
final boolean writer;
this.interruptible = interruptible;
}
public void run() {
if (writer)
try {
for (;;) {
if (writer) {
} else {
}
if (!interruptible) {
// give the interruptible thread a chance
try {
} catch (InterruptedException e) {
unexpected(e);
}
}
}
} catch (ClosedByInterruptException e) {
if (interruptible) {
if (Thread.interrupted()) {
expected(e + " thrown and interrupt status set");
} else {
unexpected(e + " thrown but interrupt status not set");
}
} else {
unexpected(e);
}
} catch (ClosedChannelException e) {
if (interruptible) {
unexpected(e);
} else {
expected(e);
}
} catch (Exception e) {
unexpected(e);
}
}
}
}
}
failed = true;
}
failed = true;
}
}