1 /* 2 * Copyright (c) 2008, 2010, 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 /* @test 25 * @bug 4313887 6993267 26 * @summary Unit test for Sun-specific ExtendedCopyOption.INTERRUPTIBLE option 27 * @library .. 28 * @run main/othervm -XX:-UseVMInterruptibleIO InterruptCopy 29 */ 30 31 import java.nio.file.*; 32 import java.nio.file.attribute.Attributes; 33 import java.io.*; 34 import java.util.concurrent.*; 35 import com.sun.nio.file.ExtendedCopyOption; 36 37 public class InterruptCopy { 38 39 private static final long FILE_SIZE_TO_COPY = 512L * 1024L * 1024L; 40 private static final int DELAY_IN_MS = 500; 41 private static final int DURATION_MAX_IN_MS = 5000; 42 43 public static void main(String[] args) throws Exception { 44 Path dir = TestUtil.createTemporaryDirectory(); 45 try { 46 FileStore store = dir.getFileStore(); 47 System.out.format("Checking space (%s)\n", store); 48 long usableSpace = Attributes 49 .readFileStoreSpaceAttributes(store).usableSpace(); 50 if (usableSpace < 2*FILE_SIZE_TO_COPY) { 51 System.out.println("Insufficient disk space to run test."); 52 return; 53 } 54 doTest(dir); 55 } finally { 56 TestUtil.removeAll(dir); 57 } 58 } 59 60 static void doTest(Path dir) throws Exception { 61 final Path source = dir.resolve("foo"); 62 final Path target = dir.resolve("bar"); 63 64 // create source file (don't create it as sparse file because we 65 // require the copy to take a long time) 66 System.out.println("Creating source file..."); 67 byte[] buf = new byte[32*1024]; 68 long total = 0; 69 OutputStream out = source.newOutputStream(); 70 try { 71 do { 72 out.write(buf); 73 total += buf.length; 74 } while (total < FILE_SIZE_TO_COPY); 75 } finally { 76 out.close(); 77 } 78 System.out.println("Source file created."); 79 80 ScheduledExecutorService pool = 81 Executors.newSingleThreadScheduledExecutor(); 82 try { 83 // copy source to target in main thread, interrupting it after a delay 84 final Thread me = Thread.currentThread(); 85 Future<?> wakeup = pool.schedule(new Runnable() { 86 public void run() { 87 me.interrupt(); 88 }}, DELAY_IN_MS, TimeUnit.MILLISECONDS); 89 System.out.println("Copying file..."); 90 try { 91 long start = System.currentTimeMillis(); 92 source.copyTo(target, ExtendedCopyOption.INTERRUPTIBLE); 93 long duration = System.currentTimeMillis() - start; 94 if (duration > DURATION_MAX_IN_MS) 95 throw new RuntimeException("Copy was not interrupted"); 96 } catch (IOException e) { 97 boolean interrupted = Thread.interrupted(); 98 if (!interrupted) 99 throw new RuntimeException("Interrupt status was not set"); 100 System.out.println("Copy failed (this is expected)"); 101 } 102 try { 103 wakeup.get(); 104 } catch (InterruptedException ignore) { } 105 Thread.interrupted(); 106 107 // copy source to target via task in thread pool, interrupting it after 108 // a delay using cancel(true) 109 Future<Void> result = pool.submit(new Callable<Void>() { 110 public Void call() throws IOException { 111 System.out.println("Copying file..."); 112 source.copyTo(target, ExtendedCopyOption.INTERRUPTIBLE, 113 StandardCopyOption.REPLACE_EXISTING); 114 return null; 115 } 116 }); 117 Thread.sleep(DELAY_IN_MS); 118 boolean cancelled = result.cancel(true); 119 if (!cancelled) 120 result.get(); 121 System.out.println("Copy cancelled."); 122 } finally { 123 pool.shutdown(); 124 } 125 } 126 }