--- old/test/jdk/java/io/InputStream/Skip.java 2018-11-16 17:19:39.000000000 -0800 +++ new/test/jdk/java/io/InputStream/Skip.java 2018-11-16 17:19:39.000000000 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2018 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 @@ -21,24 +21,22 @@ * questions. */ +/** + * @test + * @bug 4016710 6516099 + * @summary check for correct implementation of InputStream.skip{NBytes} + */ -/* @test - @bug 4016710 - @summary check for correct implementation of InputStream.skip - */ - -import java.io.*; - - -public class Skip{ +import java.io.EOFException; +import java.io.InputStream; +import java.io.IOException; - private static void dotest(InputStream in , int curpos , - long total , long toskip , long expected) - throws Exception - { +public class Skip { + private static final int EOF = -1; + private static void dotest(InputStream in, int curpos, long total, + long toskip, long expected) throws Exception { try { - System.err.println("\n\nCurrently at pos = " + curpos + "\nTotal bytes in the Stream = " + total + "\nNumber of bytes to skip = " + toskip + @@ -50,43 +48,69 @@ System.err.println("actual number skipped: "+ skipped); if ((skipped < 0) || (skipped > expected)) { - throw new RuntimeException("Unexpected number of bytes skipped"); + throw new RuntimeException("Unexpected byte count skipped"); } - } catch (IOException e) { - System.err.println("IOException is thrown - possible result"); + System.err.println("IOException is thrown: " + e); } catch (Throwable e) { - throw new RuntimeException("Unexpected "+e+" is thrown!"); + throw new RuntimeException("Unexpected " + e + " is thrown!"); } + } + + private static void dotestExact(MyInputStream in, long curpos, long total, + long toskip, boolean expectIOE, boolean expectEOFE) { + System.err.println("\n\nCurrently at pos = " + curpos + + "\nTotal bytes in the Stream = " + total + + "\nNumber of bytes to skip = " + toskip); + + try { + long pos = in.position(); + assert pos == curpos : pos + " != " + curpos; + in.skipNBytes(toskip); + if (in.position() != pos + (toskip < 0 ? 0 : toskip)) { + throw new RuntimeException((in.position() - pos) + + " bytes skipped; expected " + toskip); + } + } catch (EOFException eofe) { + if (!expectEOFE) { + throw new RuntimeException("Unexpected EOFException", eofe); + } + System.err.println("Caught expected EOFException"); + } catch (IOException ioe) { + if (!expectIOE) { + throw new RuntimeException("Unexpected IOException", ioe); + } + System.err.println("Caught expected IOException"); + } } public static void main( String argv[] ) throws Exception { - MyInputStream in = new MyInputStream(11); - /* test for negative skip */ + // test for negative skip dotest(in, 0, 11, -23, 0); - /* check for skip beyond EOF starting from before EOF */ + // check for skip beyond EOF starting from before EOF dotest(in, 0, 11, 20, 11); - /* check for skip after EOF */ - dotest(in, -1, 11, 20, 0); + // check for skip after EOF + dotest(in, EOF, 11, 20, 0); in = new MyInputStream(9000); - /* check for skip equal to the read chunk size in InputStream.java */ + + // check for skip equal to the read chunk size in InputStream.java dotest(in, 0, 9000, 2048, 2048); - /* check for skip greater than the read chunk size in InputStream.java */ + // check for skip larger than the read chunk size in InputStream.java dotest(in, 2048, 9000, 5000, 5000); - /* check for skip beyond EOF starting from before EOF */ + // check for skip beyond EOF starting from before EOF dotest(in, 7048, 9000, 5000, 1952); in = new MyInputStream(5000); - /* check for multiple chunk reads */ + // check for multiple chunk reads dotest(in, 0, 5000, 6000, 5000); /* @@ -98,23 +122,85 @@ * dotest(in, 0, total, toskip, toskip); */ - } + // tests for skipping an exact number of bytes + + final long streamLength = Long.MAX_VALUE; + in = new MyInputStream(streamLength); + // negative skip: OK + dotestExact(in, 0, streamLength, -1, false, false); + + // negative skip at EOF: OK + in.position(streamLength); + dotestExact(in, streamLength, streamLength, -1, false, false); + in.position(0); + + // zero skip: OK + dotestExact(in, 0, streamLength, 0, false, false); + + // zero skip at EOF: OK + in.position(streamLength); + dotestExact(in, streamLength, streamLength, 0, false, false); + + // skip(1) at EOF: EOFE + dotestExact(in, streamLength, streamLength, 1, false, true); + in.position(0); + + final long n = 31; // skip count + long pos = 0; + + // skip(n) returns negative value: IOE + in.setState(-1, 100); + dotestExact(in, pos, streamLength, n, true, false); + + // skip(n) returns n + 1: IOE + in.setState(n + 1, 100); + dotestExact(in, pos, streamLength, n, true, false); + + // skip(n) returns n/2 but only n/4 subsequent reads succeed: EOFE + in.setState(n/2, n/2 + n/4); + dotestExact(in, pos, streamLength, n, false, true); + pos += n/2 + n/4; + + // skip(n) returns n/2 but n - n/2 subsequent reads succeed: OK + in.setState(n/2, n); + dotestExact(in, pos, streamLength, n, false, false); + pos += n; + } } class MyInputStream extends InputStream { + private static final int EOF = -1; - private int readctr = 0; - private long endoffile; + private final long endoffile; + + private long readctr = 0; + + private boolean isStateSet = false; + private long skipReturn; + private long readLimit; public MyInputStream(long endoffile) { this.endoffile = endoffile; } - public int read() { + /** + * Limits the behavior of skip() and read(). + * + * @param skipReturn the value to be returned by skip() + * @param maxReads the maximum number of reads past the current position + * before EOF is reached + */ + public void setState(long skipReturn, long maxReads) { + this.skipReturn = skipReturn; + this.readLimit = readctr + maxReads; + isStateSet = true; + } - if (readctr == endoffile) { - return -1; + public int read() { + if (readctr == endoffile || + (isStateSet && readctr >= readLimit)) { + return EOF; } else { readctr++; @@ -123,4 +209,19 @@ } public int available() { return 0; } + + public long position() { return readctr == endoffile ? EOF : readctr; } + + public void position(long pos) { + readctr = pos < 0 ? 0 : Math.min(pos, endoffile); + } + + public long skip(long n) throws IOException { + if (isStateSet) { + return super.skip(skipReturn); + } + + // InputStream skip implementation. + return super.skip(n); // readctr is implicitly incremented + } }