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