001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.io.input; 018 019import static org.apache.commons.io.IOUtils.EOF; 020 021import java.io.EOFException; 022import java.io.IOException; 023import java.io.InputStream; 024 025/** 026 * A functional, light weight {@link InputStream} that emulates 027 * a stream of a specified size. 028 * <p> 029 * This implementation provides a light weight 030 * object for testing with an {@link InputStream} 031 * where the contents don't matter. 032 * </p> 033 * <p> 034 * One use case would be for testing the handling of 035 * large {@link InputStream} as it can emulate that 036 * scenario without the overhead of actually processing 037 * large numbers of bytes - significantly speeding up 038 * test execution times. 039 * </p> 040 * <p> 041 * This implementation returns zero from the method that 042 * reads a byte and leaves the array unchanged in the read 043 * methods that are passed a byte array. 044 * If alternative data is required the {@code processByte()} and 045 * {@code processBytes()} methods can be implemented to generate 046 * data, for example: 047 * </p> 048 * 049 * <pre> 050 * public class TestInputStream extends NullInputStream { 051 * public TestInputStream(int size) { 052 * super(size); 053 * } 054 * protected int processByte() { 055 * return ... // return required value here 056 * } 057 * protected void processBytes(byte[] bytes, int offset, int length) { 058 * for (int i = offset; i < length; i++) { 059 * bytes[i] = ... // set array value here 060 * } 061 * } 062 * } 063 * </pre> 064 * 065 * @since 1.3 066 * 067 */ 068public class NullInputStream extends InputStream { 069 070 private final long size; 071 private long position; 072 private long mark = -1; 073 private long readlimit; 074 private boolean eof; 075 private final boolean throwEofException; 076 private final boolean markSupported; 077 078 /** 079 * Create an {@link InputStream} that emulates a size 0 stream 080 * which supports marking and does not throw EOFException. 081 * 082 * @since 2.7 083 */ 084 public NullInputStream() { 085 this(0, true, false); 086 } 087 088 /** 089 * Create an {@link InputStream} that emulates a specified size 090 * which supports marking and does not throw EOFException. 091 * 092 * @param size The size of the input stream to emulate. 093 */ 094 public NullInputStream(final long size) { 095 this(size, true, false); 096 } 097 098 /** 099 * Create an {@link InputStream} that emulates a specified 100 * size with option settings. 101 * 102 * @param size The size of the input stream to emulate. 103 * @param markSupported Whether this instance will support 104 * the {@code mark()} functionality. 105 * @param throwEofException Whether this implementation 106 * will throw an {@link EOFException} or return -1 when the 107 * end of file is reached. 108 */ 109 public NullInputStream(final long size, final boolean markSupported, final boolean throwEofException) { 110 this.size = size; 111 this.markSupported = markSupported; 112 this.throwEofException = throwEofException; 113 } 114 115 /** 116 * Return the current position. 117 * 118 * @return the current position. 119 */ 120 public long getPosition() { 121 return position; 122 } 123 124 /** 125 * Return the size this {@link InputStream} emulates. 126 * 127 * @return The size of the input stream to emulate. 128 */ 129 public long getSize() { 130 return size; 131 } 132 133 /** 134 * Return the number of bytes that can be read. 135 * 136 * @return The number of bytes that can be read. 137 */ 138 @Override 139 public int available() { 140 final long avail = size - position; 141 if (avail <= 0) { 142 return 0; 143 } 144 if (avail > Integer.MAX_VALUE) { 145 return Integer.MAX_VALUE; 146 } 147 return (int) avail; 148 } 149 150 /** 151 * Close this input stream - resets the internal state to 152 * the initial values. 153 * 154 * @throws IOException If an error occurs. 155 */ 156 @Override 157 public void close() throws IOException { 158 eof = false; 159 position = 0; 160 mark = -1; 161 } 162 163 /** 164 * Mark the current position. 165 * 166 * @param readlimit The number of bytes before this marked position 167 * is invalid. 168 * @throws UnsupportedOperationException if mark is not supported. 169 */ 170 @Override 171 public synchronized void mark(final int readlimit) { 172 if (!markSupported) { 173 throw UnsupportedOperationExceptions.mark(); 174 } 175 mark = position; 176 this.readlimit = readlimit; 177 } 178 179 /** 180 * Indicates whether <i>mark</i> is supported. 181 * 182 * @return Whether <i>mark</i> is supported or not. 183 */ 184 @Override 185 public boolean markSupported() { 186 return markSupported; 187 } 188 189 /** 190 * Read a byte. 191 * 192 * @return Either The byte value returned by {@code processByte()} 193 * or {@code -1} if the end of file has been reached and 194 * {@code throwEofException} is set to {@code false}. 195 * @throws EOFException if the end of file is reached and 196 * {@code throwEofException} is set to {@code true}. 197 * @throws IOException if trying to read past the end of file. 198 */ 199 @Override 200 public int read() throws IOException { 201 if (eof) { 202 throw new IOException("Read after end of file"); 203 } 204 if (position == size) { 205 return doEndOfFile(); 206 } 207 position++; 208 return processByte(); 209 } 210 211 /** 212 * Read some bytes into the specified array. 213 * 214 * @param bytes The byte array to read into 215 * @return The number of bytes read or {@code -1} 216 * if the end of file has been reached and 217 * {@code throwEofException} is set to {@code false}. 218 * @throws EOFException if the end of file is reached and 219 * {@code throwEofException} is set to {@code true}. 220 * @throws IOException if trying to read past the end of file. 221 */ 222 @Override 223 public int read(final byte[] bytes) throws IOException { 224 return read(bytes, 0, bytes.length); 225 } 226 227 /** 228 * Read the specified number bytes into an array. 229 * 230 * @param bytes The byte array to read into. 231 * @param offset The offset to start reading bytes into. 232 * @param length The number of bytes to read. 233 * @return The number of bytes read or {@code -1} 234 * if the end of file has been reached and 235 * {@code throwEofException} is set to {@code false}. 236 * @throws EOFException if the end of file is reached and 237 * {@code throwEofException} is set to {@code true}. 238 * @throws IOException if trying to read past the end of file. 239 */ 240 @Override 241 public int read(final byte[] bytes, final int offset, final int length) throws IOException { 242 if (eof) { 243 throw new IOException("Read after end of file"); 244 } 245 if (position == size) { 246 return doEndOfFile(); 247 } 248 position += length; 249 int returnLength = length; 250 if (position > size) { 251 returnLength = length - (int)(position - size); 252 position = size; 253 } 254 processBytes(bytes, offset, returnLength); 255 return returnLength; 256 } 257 258 /** 259 * Reset the stream to the point when mark was last called. 260 * 261 * @throws UnsupportedOperationException if mark is not supported. 262 * @throws IOException If no position has been marked 263 * or the read limit has been exceed since the last position was 264 * marked. 265 */ 266 @Override 267 public synchronized void reset() throws IOException { 268 if (!markSupported) { 269 throw UnsupportedOperationExceptions.reset(); 270 } 271 if (mark < 0) { 272 throw new IOException("No position has been marked"); 273 } 274 if (position > mark + readlimit) { 275 throw new IOException("Marked position [" + mark + 276 "] is no longer valid - passed the read limit [" + 277 readlimit + "]"); 278 } 279 position = mark; 280 eof = false; 281 } 282 283 /** 284 * Skip a specified number of bytes. 285 * 286 * @param numberOfBytes The number of bytes to skip. 287 * @return The number of bytes skipped or {@code -1} 288 * if the end of file has been reached and 289 * {@code throwEofException} is set to {@code false}. 290 * @throws EOFException if the end of file is reached and 291 * {@code throwEofException} is set to {@code true}. 292 * @throws IOException if trying to read past the end of file. 293 */ 294 @Override 295 public long skip(final long numberOfBytes) throws IOException { 296 if (eof) { 297 throw new IOException("Skip after end of file"); 298 } 299 if (position == size) { 300 return doEndOfFile(); 301 } 302 position += numberOfBytes; 303 long returnLength = numberOfBytes; 304 if (position > size) { 305 returnLength = numberOfBytes - (position - size); 306 position = size; 307 } 308 return returnLength; 309 } 310 311 /** 312 * Return a byte value for the {@code read()} method. 313 * <p> 314 * This implementation returns zero. 315 * 316 * @return This implementation always returns zero. 317 */ 318 protected int processByte() { 319 // do nothing - overridable by subclass 320 return 0; 321 } 322 323 /** 324 * Process the bytes for the {@code read(byte[], offset, length)} 325 * method. 326 * <p> 327 * This implementation leaves the byte array unchanged. 328 * 329 * @param bytes The byte array 330 * @param offset The offset to start at. 331 * @param length The number of bytes. 332 */ 333 protected void processBytes(final byte[] bytes, final int offset, final int length) { 334 // do nothing - overridable by subclass 335 } 336 337 /** 338 * Handle End of File. 339 * 340 * @return {@code -1} if {@code throwEofException} is 341 * set to {@code false} 342 * @throws EOFException if {@code throwEofException} is set 343 * to {@code true}. 344 */ 345 private int doEndOfFile() throws EOFException { 346 eof = true; 347 if (throwEofException) { 348 throw new EOFException(); 349 } 350 return EOF; 351 } 352 353}