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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright (c) 1998, 2024, 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 4028605 4109069 4234207 4401122 8339154
* @summary Verify that ZipInputStream, InflaterInputStream, ZipFileInputStream,
* ZipFileInflaterInputStream.available() return values according
* to their specification or long-standing behavior
* @run junit Available
*/
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.zip.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class Available {
// ZIP file produced in this test
private final Path zip = Path.of("available.jar");
/**
* Create the ZIP file used in this test, containing
* one deflated and one stored entry.
*
* @throws IOException if an unexpected error occurs
*/
@BeforeEach
public void setup() throws IOException {
byte[] contents = "contents".repeat(10).getBytes(StandardCharsets.UTF_8);
try (ZipOutputStream zo = new ZipOutputStream(Files.newOutputStream(zip))) {
// First entry uses DEFLATE method
zo.putNextEntry(new ZipEntry("deflated.txt"));
zo.write(contents);
// Second entry uses STORED method
ZipEntry stored = new ZipEntry("stored.txt");
stored.setMethod(ZipEntry.STORED);
stored.setSize(contents.length);
CRC32 crc32 = new CRC32();
crc32.update(contents);
stored.setCrc(crc32.getValue());
zo.putNextEntry(stored);
zo.write(contents);
}
}
/**
* Delete the ZIP file created by this test
*
* @throws IOException if an unexpected error occurs
*/
@AfterEach
public void cleanup() throws IOException {
Files.deleteIfExists(zip);
}
/**
* Verify that ZipInputStream.available() returns 0 after EOF or
* closeEntry, otherwise 1, as specified in the API description.
* This tests 4028605 4109069 4234207
* @throws IOException if an unexpected error occurs
*/
@Test
public void testZipInputStream() throws IOException {
try (InputStream in = Files.newInputStream(zip)) {
ZipInputStream z = new ZipInputStream(in);
z.getNextEntry();
assertEquals(1, z.available());
z.read();
assertEquals(1, z.available());
z.transferTo(OutputStream.nullOutputStream());
assertEquals(0, z.available(),
"ZipInputStream.available() should return 0 after EOF");
z.close();
assertThrows(IOException.class, () -> z.available(),
"Expected an IOException when calling available on a closed stream");
}
try (InputStream in = Files.newInputStream(zip);
ZipInputStream z = new ZipInputStream(in)) {
z.getNextEntry();
z.closeEntry();
assertEquals(0, z.available(),
"ZipInputStream.available() should return 0 after closeEntry");
}
}
/**
* Verify that ZipFileInputStream|ZipFileInflaterInputStream.available()
* return the number of remaining uncompressed bytes.
*
* This verifies unspecified, but long-standing behavior. See 4401122.
*
* @throws IOException if an unexpected error occurs
*/
@ParameterizedTest
@ValueSource(strings = { "stored.txt", "deflated.txt" })
public void testZipFileStreamsRemainingBytes(String entryName) throws IOException {
try (ZipFile zfile = new ZipFile(zip.toFile())) {
ZipEntry entry = zfile.getEntry(entryName);
// Could be ZipFileInputStream or ZipFileInflaterInputStream
InputStream in = zfile.getInputStream(entry);
int initialAvailable = in.available();
// Initally, the number of remaining uncompressed bytes is the entry size
assertEquals(entry.getSize(), initialAvailable);
// Read all bytes one by one
for (int i = initialAvailable; i > 0; i--) {
// Reading a single byte should decrement available by 1
in.read();
assertEquals(i - 1, in.available(), "Available not decremented");
}
// No remaining uncompressed bytes
assertEquals(0, in.available());
// available() should still return 0 after close
in.close();
assertEquals(0, in.available());
}
}
}
|
