/*
* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* 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 8047769
* @modules java.base/java.lang.ref:open
* java.base/sun.security.provider:open
* @summary SecureRandom should be more frugal with file descriptors
*/
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.Reference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.Arrays;
public class FileInputStreamPoolTest {
static final byte[] bytes = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
static void testCaching(File file) throws IOException {
InputStream in1 = TestProxy.FileInputStreamPool_getInputStream(file);
InputStream in2 = TestProxy.FileInputStreamPool_getInputStream(file);
assertTrue(in1 == in2,
"1st InputStream: " + in1 +
" is not same as 2nd: " + in2);
byte[] readBytes = new byte[bytes.length];
int nread = in1.read(readBytes);
assertTrue(bytes.length == nread,
"short read: " + nread +
" bytes of expected: " + bytes.length);
assertTrue(Arrays.equals(readBytes, bytes),
"readBytes: " + Arrays.toString(readBytes) +
" not equal to expected: " + Arrays.toString(bytes));
}
static void assertTrue(boolean test, String message) {
if (!test) {
throw new AssertionError(message);
}
}
static void processReferences() {
// make JVM process References
System.gc();
// help ReferenceHandler thread enqueue References
while (TestProxy.Reference_waitForReferenceProcessing()) { }
// help run Finalizers
System.runFinalization();
}
public static void main(String[] args) throws Exception {
// 1st create temporary file
File file = File.createTempFile("test", ".dat");
try (AutoCloseable acf = () -> {
// On Windows, failure to delete file is probably a consequence
// of the file still being opened - so the test should fail.
assertTrue(file.delete(),
"Can't delete: " + file + " (is it still open?)");
}) {
try (FileOutputStream out = new FileOutputStream(file)) {
out.write(bytes);
}
// test caching 1t time
testCaching(file);
processReferences();
// test caching 2nd time - this should only succeed if the stream
// is re-opened as a consequence of cleared WeakReference
testCaching(file);
processReferences();
}
}
/**
* A proxy for (package)private static methods:
* sun.security.provider.FileInputStreamPool.getInputStream
* java.lang.ref.Reference.waitForReferenceProcessing
*/
static class TestProxy {
private static final Method getInputStreamMethod;
private static final Method waitForReferenceProcessingMethod;
static {
try {
Class<?> fileInputStreamPoolClass =
Class.forName("sun.security.provider.FileInputStreamPool");
getInputStreamMethod =
fileInputStreamPoolClass.getDeclaredMethod(
"getInputStream", File.class);
getInputStreamMethod.setAccessible(true);
waitForReferenceProcessingMethod =
Reference.class.getDeclaredMethod("waitForReferenceProcessing");
waitForReferenceProcessingMethod.setAccessible(true);
} catch (Exception e) {
throw new Error(e);
}
}
static InputStream FileInputStreamPool_getInputStream(File file)
throws IOException {
try {
return (InputStream) getInputStreamMethod.invoke(null, file);
} catch (InvocationTargetException e) {
Throwable te = e.getTargetException();
if (te instanceof IOException) {
throw (IOException) te;
} else if (te instanceof RuntimeException) {
throw (RuntimeException) te;
} else if (te instanceof Error) {
throw (Error) te;
} else {
throw new UndeclaredThrowableException(te);
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
static boolean Reference_waitForReferenceProcessing() {
try {
return (boolean) waitForReferenceProcessingMethod.invoke(null);
} catch (InvocationTargetException e) {
Throwable te = e.getTargetException();
if (te instanceof InterruptedException) {
return true;
} else if (te instanceof RuntimeException) {
throw (RuntimeException) te;
} else if (te instanceof Error) {
throw (Error) te;
} else {
throw new UndeclaredThrowableException(te);
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
}