1 /*
2 * Copyright (c) 2014, 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 import java.io.ByteArrayOutputStream;
25 import java.io.FilterInputStream;
26 import java.io.FilterOutputStream;
27 import java.io.IOException;
28 import java.io.InputStream;
29 import java.io.OutputStream;
30 import java.util.Arrays;
31 import java.util.Random;
32
33 import static java.lang.String.format;
34
35 /*
36 * @test
37 * @bug 8066867
38 * @summary tests whether java.io.InputStream.transferTo conforms to its
39 * contract defined in the javadoc
40 * @key randomness
41 */
42 public class TransferTo {
43
44 public static void main(String[] args) throws IOException {
45 ifOutIsNullThenNpeIsThrown();
46 ifExceptionInInputNeitherStreamIsClosed();
47 ifExceptionInOutputNeitherStreamIsClosed();
48 onReturnNeitherStreamIsClosed();
49 onReturnInputIsAtEnd();
50 contents();
51 }
52
53 private static void ifOutIsNullThenNpeIsThrown() throws IOException {
54 try (InputStream in = input()) {
55 assertThrowsNPE(() -> in.transferTo(null), "out");
56 }
57
58 try (InputStream in = input((byte) 1)) {
59 assertThrowsNPE(() -> in.transferTo(null), "out");
60 }
61
62 try (InputStream in = input((byte) 1, (byte) 2)) {
63 assertThrowsNPE(() -> in.transferTo(null), "out");
64 }
65
66 InputStream in = null;
67 try {
68 InputStream fin = in = new ThrowingInputStream();
69 // null check should precede everything else:
70 // InputStream shouldn't be touched if OutputStream is null
71 assertThrowsNPE(() -> fin.transferTo(null), "out");
72 } finally {
73 if (in != null)
74 try {
75 in.close();
76 } catch (IOException ignored) { }
77 }
78 }
79
80 private static void ifExceptionInInputNeitherStreamIsClosed()
81 throws IOException {
82 transferToThenCheckIfAnyClosed(input(0, new byte[]{1, 2, 3}), output());
83 transferToThenCheckIfAnyClosed(input(1, new byte[]{1, 2, 3}), output());
84 transferToThenCheckIfAnyClosed(input(2, new byte[]{1, 2, 3}), output());
85 }
86
87 private static void ifExceptionInOutputNeitherStreamIsClosed()
88 throws IOException {
89 transferToThenCheckIfAnyClosed(input(new byte[]{1, 2, 3}), output(0));
90 transferToThenCheckIfAnyClosed(input(new byte[]{1, 2, 3}), output(1));
91 transferToThenCheckIfAnyClosed(input(new byte[]{1, 2, 3}), output(2));
92 }
93
94 private static void transferToThenCheckIfAnyClosed(InputStream input,
95 OutputStream output)
96 throws IOException {
97 try (CloseLoggingInputStream in = new CloseLoggingInputStream(input);
98 CloseLoggingOutputStream out =
99 new CloseLoggingOutputStream(output)) {
100 boolean thrown = false;
101 try {
102 in.transferTo(out);
103 } catch (IOException ignored) {
104 thrown = true;
105 }
106 if (!thrown)
107 throw new AssertionError();
108
109 if (in.wasClosed() || out.wasClosed()) {
110 throw new AssertionError();
111 }
112 }
113 }
114
115 private static void onReturnNeitherStreamIsClosed()
116 throws IOException {
117 try (CloseLoggingInputStream in =
118 new CloseLoggingInputStream(input(new byte[]{1, 2, 3}));
119 CloseLoggingOutputStream out =
120 new CloseLoggingOutputStream(output())) {
121
122 in.transferTo(out);
123
124 if (in.wasClosed() || out.wasClosed()) {
125 throw new AssertionError();
126 }
127 }
128 }
129
130 private static void onReturnInputIsAtEnd() throws IOException {
131 try (InputStream in = input(new byte[]{1, 2, 3});
132 OutputStream out = output()) {
133
134 in.transferTo(out);
135
136 if (in.read() != -1) {
137 throw new AssertionError();
138 }
139 }
140 }
141
142 private static void contents() throws IOException {
143 checkTransferredContents(new byte[0]);
144 checkTransferredContents(createRandomBytes(1024, 4096));
145 // to span through several batches
146 checkTransferredContents(createRandomBytes(16384, 16384));
147 }
148
149 private static void checkTransferredContents(byte[] bytes)
150 throws IOException {
151 try (InputStream in = input(bytes);
152 ByteArrayOutputStream out = new ByteArrayOutputStream()) {
153 in.transferTo(out);
154
155 byte[] outBytes = out.toByteArray();
156 if (!Arrays.equals(bytes, outBytes)) {
157 throw new AssertionError(
158 format("bytes.length=%s, outBytes.length=%s",
159 bytes.length, outBytes.length));
160 }
161 }
162 }
163
164 private static byte[] createRandomBytes(int min, int maxRandomAdditive) {
165 Random rnd = new Random();
166 byte[] bytes = new byte[min + rnd.nextInt(maxRandomAdditive)];
167 rnd.nextBytes(bytes);
168 return bytes;
169 }
170
171 private static OutputStream output() {
172 return output(-1);
173 }
174
175 private static OutputStream output(int exceptionPosition) {
176 return new OutputStream() {
177
178 int pos;
179
180 @Override
181 public void write(int b) throws IOException {
182 if (pos++ == exceptionPosition)
183 throw new IOException();
184 }
185 };
186 }
187
188 private static InputStream input(byte... bytes) {
189 return input(-1, bytes);
190 }
191
192 private static InputStream input(int exceptionPosition, byte... bytes) {
193 return new InputStream() {
194
195 int pos;
196
197 @Override
198 public int read() throws IOException {
199 if (pos == exceptionPosition) {
200 // because of the pesky IOException swallowing in
201 // java.io.InputStream.read(byte[], int, int)
202 // pos++;
203 throw new IOException();
204 }
205
206 if (pos >= bytes.length)
207 return -1;
208 return bytes[pos++] & 0xff;
209 }
210 };
211 }
212
213 private static class ThrowingInputStream extends InputStream {
214
215 boolean closed;
216
217 @Override
218 public int read(byte[] b) throws IOException {
219 throw new IOException();
220 }
221
222 @Override
223 public int read(byte[] b, int off, int len) throws IOException {
224 throw new IOException();
225 }
226
227 @Override
228 public long skip(long n) throws IOException {
229 throw new IOException();
230 }
231
232 @Override
233 public int available() throws IOException {
234 throw new IOException();
235 }
236
237 @Override
238 public void close() throws IOException {
239 if (!closed) {
240 closed = true;
241 throw new IOException();
242 }
243 }
244
245 @Override
246 public void reset() throws IOException {
247 throw new IOException();
248 }
249
250 @Override
251 public int read() throws IOException {
252 throw new IOException();
253 }
254 }
255
256 private static class CloseLoggingInputStream extends FilterInputStream {
257
258 boolean closed;
259
260 CloseLoggingInputStream(InputStream in) {
261 super(in);
262 }
263
264 @Override
265 public void close() throws IOException {
266 closed = true;
267 super.close();
268 }
269
270 boolean wasClosed() {
271 return closed;
272 }
273 }
274
275 private static class CloseLoggingOutputStream extends FilterOutputStream {
276
277 boolean closed;
278
279 CloseLoggingOutputStream(OutputStream out) {
280 super(out);
281 }
282
283 @Override
284 public void close() throws IOException {
285 closed = true;
286 super.close();
287 }
288
289 boolean wasClosed() {
290 return closed;
291 }
292 }
293
294 public interface Thrower {
295 public void run() throws Throwable;
296 }
297
298 public static void assertThrowsNPE(Thrower thrower, String message) {
299 assertThrows(thrower, NullPointerException.class, message);
300 }
301
302 public static <T extends Throwable> void assertThrows(Thrower thrower,
303 Class<T> throwable,
304 String message) {
305 Throwable thrown;
306 try {
307 thrower.run();
308 thrown = null;
309 } catch (Throwable caught) {
310 thrown = caught;
311 }
312
313 if (!throwable.isInstance(thrown)) {
314 String caught = thrown == null ?
315 "nothing" : thrown.getClass().getCanonicalName();
316 throw new AssertionError(
317 format("Expected to catch %s, but caught %s",
318 throwable, caught), thrown);
319 }
320
321 if (thrown != null && !message.equals(thrown.getMessage())) {
322 throw new AssertionError(
323 format("Expected exception message to be '%s', but it's '%s'",
324 message, thrown.getMessage()));
325 }
326 }
327 }