1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Copyright (c) 2010, 2017, 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 6402006 7030573 8011136
* @summary Test if available returns correct value when reading
* a large file.
* @run main/timeout=300 LargeFileAvailable
*/
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Files;
import static java.nio.file.StandardOpenOption.*;
import java.util.concurrent.TimeUnit;
public class LargeFileAvailable {
public static void main(String args[]) throws Exception {
// Create a temporary file in the current directory.
// Use it to check if we have 7G available for
// a large sparse file test. As a fallback use whatever
// space is available, so the test can proceed.
File file = File.createTempFile("largefile", null, new File("."));
long spaceavailable = file.getUsableSpace();
long filesize = Math.min(spaceavailable, 7405576182L);
if (spaceavailable == 0L) {
// A full disk is considered fatal.
throw new RuntimeException("No space available for temp file.");
}
createLargeFile(filesize, file);
try (FileInputStream fis = new FileInputStream(file)) {
if (file.length() != filesize) {
throw new RuntimeException("unexpected file size = "
+ file.length());
}
long bigSkip = Math.min(filesize/2, 3110608882L);
long remaining = filesize;
remaining -= skipBytes(fis, bigSkip, remaining);
remaining -= skipBytes(fis, 10L, remaining);
remaining -= skipBytes(fis, bigSkip, remaining);
int expected = (remaining >= Integer.MAX_VALUE)
? Integer.MAX_VALUE
: (remaining > 0 ? (int) remaining : 0);
if (fis.available() != expected) {
throw new RuntimeException("available() returns "
+ fis.available() + " but expected " + expected);
}
} finally {
file.delete();
}
System.out.println("Test succeeded.");
System.out.flush();
}
// Skip toSkip number of bytes and expect that the available() method
// returns avail number of bytes.
private static long skipBytes(InputStream is, long toSkip, long avail)
throws IOException {
long skip = is.skip(toSkip);
if (skip != toSkip) {
throw new RuntimeException("skip() returns " + skip
+ " but expected " + toSkip);
}
long remaining = avail - skip;
int expected = (remaining >= Integer.MAX_VALUE)
? Integer.MAX_VALUE
: (remaining > 0 ? (int) remaining : 0);
System.out.println("Skipped " + skip + " bytes, available() returns "
+ expected + ", remaining " + remaining);
if (is.available() != expected) {
throw new RuntimeException("available() returns "
+ is.available() + " but expected " + expected);
}
return skip;
}
private static void createLargeFile(long filesize,
File file) throws Exception {
// Recreate a large file as a sparse file if possible
Files.delete(file.toPath());
try (FileChannel fc =
FileChannel.open(file.toPath(),
CREATE_NEW, WRITE, SPARSE)) {
ByteBuffer bb = ByteBuffer.allocate(1).put((byte)1);
bb.rewind();
System.out.println(" Writing large file...");
long t0 = System.nanoTime();
int rc = fc.write(bb, filesize - 1);
long t1 = System.nanoTime();
System.out.printf(" Wrote large file in %d ns (%d ms) %n",
t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
if (rc != 1) {
throw new RuntimeException("Failed to write 1 byte"
+ " to the large file");
}
}
return;
}
}
|
