Coverage Report

Coverage Report - org.apache.commons.io.input.NullReader

Classes in this File

Line Coverage

Branch Coverage

Complexity

NullReader

96%

61/63

100%

26/26

2.6

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.io.input;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.Reader;
 
 /**
  * A functional, light weight {@link Reader} that emulates
  * a reader of a specified size.
  * <p>
  * This implementation provides a light weight
  * object for testing with an {@link Reader}
  * where the contents don't matter.
  * <p>
  * One use case would be for testing the handling of
  * large {@link Reader} as it can emulate that
  * scenario without the overhead of actually processing
  * large numbers of characters - significantly speeding up
  * test execution times.
  * <p>
  * This implementation returns a space from the method that
  * reads a character and leaves the array unchanged in the read
  * methods that are passed a character array.
  * If alternative data is required the <code>processChar()</code> and
  * <code>processChars()</code> methods can be implemented to generate
  * data, for example:
  *
  * <pre>
  *  public class TestReader extends NullReader {
  *      public TestReader(int size) {
  *          super(size);
  *      }
  *      protected char processChar() {
  *          return ... // return required value here
  *      }
  *      protected void processChars(char[] chars, int offset, int length) {
  *          for (int i = offset; i < length; i++) {
  *              chars[i] = ... // set array value here
  *          }
  *      }
  *  }
  * </pre>
  *
  * @since 1.3
  * @version $Id: NullReader.java 1415850 2012-11-30 20:51:39Z ggregory $
  */
 public class NullReader extends Reader {
 
     private final long size;
     private long position;
     private long mark = -1;
     private long readlimit;
     private boolean eof;
     private final boolean throwEofException;
     private final boolean markSupported;
 
     /**
      * Create a {@link Reader} that emulates a specified size
      * which supports marking and does not throw EOFException.
      *
      * @param size The size of the reader to emulate.
      */
     public NullReader(final long size) {
        this(size, true, false);
     }
 
     /**
      * Create a {@link Reader} that emulates a specified
      * size with option settings.
      *
      * @param size The size of the reader to emulate.
      * @param markSupported Whether this instance will support
      * the <code>mark()</code> functionality.
      * @param throwEofException Whether this implementation
      * will throw an {@link EOFException} or return -1 when the
      * end of file is reached.
      */
     public NullReader(final long size, final boolean markSupported, final boolean throwEofException) {
        this.size = size;
        this.markSupported = markSupported;
        this.throwEofException = throwEofException;
     }
 
     /**
      * Return the current position.
      *
      * @return the current position.
      */
     public long getPosition() {
         return position;
     }
 
     /**
      * Return the size this {@link Reader} emulates.
      *
      * @return The size of the reader to emulate.
      */
     public long getSize() {
         return size;
     }
 
     /**
      * Close this Reader - resets the internal state to
      * the initial values.
      *
      * @throws IOException If an error occurs.
      */
     @Override
     public void close() throws IOException {
         eof = false;
         position = 0;
         mark = -1;
     }
 
     /**
      * Mark the current position.
      *
      * @param readlimit The number of characters before this marked position
      * is invalid.
      * @throws UnsupportedOperationException if mark is not supported.
      */
     @Override
     public synchronized void mark(final int readlimit) {
         if (!markSupported) {
             throw new UnsupportedOperationException("Mark not supported");
         }
         mark = position;
         this.readlimit = readlimit;
     }
 
     /**
      * Indicates whether <i>mark</i> is supported.
      *
      * @return Whether <i>mark</i> is supported or not.
      */
     @Override
     public boolean markSupported() {
         return markSupported;
     }
 
     /**
      * Read a character.
      *
      * @return Either The character value returned by <code>processChar()</code>
      * or <code>-1</code> if the end of file has been reached and
      * <code>throwEofException</code> is set to {@code false}.
      * @throws EOFException if the end of file is reached and
      * <code>throwEofException</code> is set to {@code true}.
      * @throws IOException if trying to read past the end of file.
      */
     @Override
     public int read() throws IOException {
         if (eof) {
             throw new IOException("Read after end of file");
         }
         if (position == size) {
             return doEndOfFile();
         }
         position++;
         return processChar();
     }
 
     /**
      * Read some characters into the specified array.
      *
      * @param chars The character array to read into
      * @return The number of characters read or <code>-1</code>
      * if the end of file has been reached and
      * <code>throwEofException</code> is set to {@code false}.
      * @throws EOFException if the end of file is reached and
      * <code>throwEofException</code> is set to {@code true}.
      * @throws IOException if trying to read past the end of file.
      */
     @Override
     public int read(final char[] chars) throws IOException {
         return read(chars, 0, chars.length);
     }
 
     /**
      * Read the specified number characters into an array.
      *
      * @param chars The character array to read into.
      * @param offset The offset to start reading characters into.
      * @param length The number of characters to read.
      * @return The number of characters read or <code>-1</code>
      * if the end of file has been reached and
      * <code>throwEofException</code> is set to {@code false}.
      * @throws EOFException if the end of file is reached and
      * <code>throwEofException</code> is set to {@code true}.
      * @throws IOException if trying to read past the end of file.
      */
     @Override
     public int read(final char[] chars, final int offset, final int length) throws IOException {
         if (eof) {
             throw new IOException("Read after end of file");
         }
         if (position == size) {
             return doEndOfFile();
         }
         position += length;
         int returnLength = length;
         if (position > size) {
             returnLength = length - (int)(position - size);
             position = size;
         }
         processChars(chars, offset, returnLength);
         return returnLength;
     }
 
     /**
      * Reset the stream to the point when mark was last called.
      *
      * @throws UnsupportedOperationException if mark is not supported.
      * @throws IOException If no position has been marked
      * or the read limit has been exceed since the last position was
      * marked.
      */
     @Override
     public synchronized void reset() throws IOException {
         if (!markSupported) {
             throw new UnsupportedOperationException("Mark not supported");
         }
         if (mark < 0) {
             throw new IOException("No position has been marked");
         }
         if (position > mark + readlimit) {
             throw new IOException("Marked position [" + mark +
                     "] is no longer valid - passed the read limit [" +
                     readlimit + "]");
         }
         position = mark;
         eof = false;
     }
 
     /**
      * Skip a specified number of characters.
      *
      * @param numberOfChars The number of characters to skip.
      * @return The number of characters skipped or <code>-1</code>
      * if the end of file has been reached and
      * <code>throwEofException</code> is set to {@code false}.
      * @throws EOFException if the end of file is reached and
      * <code>throwEofException</code> is set to {@code true}.
      * @throws IOException if trying to read past the end of file.
      */
     @Override
     public long skip(final long numberOfChars) throws IOException {
         if (eof) {
             throw new IOException("Skip after end of file");
         }
         if (position == size) {
             return doEndOfFile();
         }
         position += numberOfChars;
         long returnLength = numberOfChars;
         if (position > size) {
             returnLength = numberOfChars - (position - size);
             position = size;
         }
         return returnLength;
     }
 
     /**
      * Return a character value for the  <code>read()</code> method.
      * <p>
      * This implementation returns zero.
      *
      * @return This implementation always returns zero.
      */
     protected int processChar() {
         // do nothing - overridable by subclass
         return 0;
     }
 
     /**
      * Process the characters for the <code>read(char[], offset, length)</code>
      * method.
      * <p>
      * This implementation leaves the character array unchanged.
      *
      * @param chars The character array
      * @param offset The offset to start at.
      * @param length The number of characters.
      */
     protected void processChars(final char[] chars, final int offset, final int length) {
         // do nothing - overridable by subclass
     }
 
     /**
      * Handle End of File.
      *
      * @return <code>-1</code> if <code>throwEofException</code> is
      * set to {@code false}
      * @throws EOFException if <code>throwEofException</code> is set
      * to {@code true}.
      */
     private int doEndOfFile() throws EOFException {
         eof = true;
         if (throwEofException) {
             throw new EOFException();
         }
         return -1;
     }
 
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.io.input;
18
19		import java.io.EOFException;
20		import java.io.IOException;
21		import java.io.Reader;
22
23		/**
24		* A functional, light weight {@link Reader} that emulates
25		* a reader of a specified size.
26		* <p>
27		* This implementation provides a light weight
28		* object for testing with an {@link Reader}
29		* where the contents don't matter.
30		* <p>
31		* One use case would be for testing the handling of
32		* large {@link Reader} as it can emulate that
33		* scenario without the overhead of actually processing
34		* large numbers of characters - significantly speeding up
35		* test execution times.
36		* <p>
37		* This implementation returns a space from the method that
38		* reads a character and leaves the array unchanged in the read
39		* methods that are passed a character array.
40		* If alternative data is required the <code>processChar()</code> and
41		* <code>processChars()</code> methods can be implemented to generate
42		* data, for example:
43		*
44		* <pre>
45		* public class TestReader extends NullReader {
46		* public TestReader(int size) {
47		* super(size);
48		* }
49		* protected char processChar() {
50		* return ... // return required value here
51		* }
52		* protected void processChars(char[] chars, int offset, int length) {
53		* for (int i = offset; i < length; i++) {
54		* chars[i] = ... // set array value here
55		* }
56		* }
57		* }
58		* </pre>
59		*
60		* @since 1.3
61		* @version $Id: NullReader.java 1415850 2012-11-30 20:51:39Z ggregory $
62		*/
63		public class NullReader extends Reader {
64
65		private final long size;
66		private long position;
67	9	private long mark = -1;
68		private long readlimit;
69		private boolean eof;
70		private final boolean throwEofException;
71		private final boolean markSupported;
72
73		/**
74		* Create a {@link Reader} that emulates a specified size
75		* which supports marking and does not throw EOFException.
76		*
77		* @param size The size of the reader to emulate.
78		*/
79		public NullReader(final long size) {
80	5	this(size, true, false);
81	5	}
82
83		/**
84		* Create a {@link Reader} that emulates a specified
85		* size with option settings.
86		*
87		* @param size The size of the reader to emulate.
88		* @param markSupported Whether this instance will support
89		* the <code>mark()</code> functionality.
90		* @param throwEofException Whether this implementation
91		* will throw an {@link EOFException} or return -1 when the
92		* end of file is reached.
93		*/
94	9	public NullReader(final long size, final boolean markSupported, final boolean throwEofException) {
95	9	this.size = size;
96	9	this.markSupported = markSupported;
97	9	this.throwEofException = throwEofException;
98	9	}
99
100		/**
101		* Return the current position.
102		*
103		* @return the current position.
104		*/
105		public long getPosition() {
106	31	return position;
107		}
108
109		/**
110		* Return the size this {@link Reader} emulates.
111		*
112		* @return The size of the reader to emulate.
113		*/
114		public long getSize() {
115	0	return size;
116		}
117
118		/**
119		* Close this Reader - resets the internal state to
120		* the initial values.
121		*
122		* @throws IOException If an error occurs.
123		*/
124		@Override
125		public void close() throws IOException {
126	9	eof = false;
127	9	position = 0;
128	9	mark = -1;
129	9	}
130
131		/**
132		* Mark the current position.
133		*
134		* @param readlimit The number of characters before this marked position
135		* is invalid.
136		* @throws UnsupportedOperationException if mark is not supported.
137		*/
138		@Override
139		public synchronized void mark(final int readlimit) {
140	2	if (!markSupported) {
141	1	throw new UnsupportedOperationException("Mark not supported");
142		}
143	1	mark = position;
144	1	this.readlimit = readlimit;
145	1	}
146
147		/**
148		* Indicates whether <i>mark</i> is supported.
149		*
150		* @return Whether <i>mark</i> is supported or not.
151		*/
152		@Override
153		public boolean markSupported() {
154	2	return markSupported;
155		}
156
157		/**
158		* Read a character.
159		*
160		* @return Either The character value returned by <code>processChar()</code>
161		* or <code>-1</code> if the end of file has been reached and
162		* <code>throwEofException</code> is set to {@code false}.
163		* @throws EOFException if the end of file is reached and
164		* <code>throwEofException</code> is set to {@code true}.
165		* @throws IOException if trying to read past the end of file.
166		*/
167		@Override
168		public int read() throws IOException {
169	30	if (eof) {
170	1	throw new IOException("Read after end of file");
171		}
172	29	if (position == size) {
173	2	return doEndOfFile();
174		}
175	27	position++;
176	27	return processChar();
177		}
178
179		/**
180		* Read some characters into the specified array.
181		*
182		* @param chars The character array to read into
183		* @return The number of characters read or <code>-1</code>
184		* if the end of file has been reached and
185		* <code>throwEofException</code> is set to {@code false}.
186		* @throws EOFException if the end of file is reached and
187		* <code>throwEofException</code> is set to {@code true}.
188		* @throws IOException if trying to read past the end of file.
189		*/
190		@Override
191		public int read(final char[] chars) throws IOException {
192	1048582	return read(chars, 0, chars.length);
193		}
194
195		/**
196		* Read the specified number characters into an array.
197		*
198		* @param chars The character array to read into.
199		* @param offset The offset to start reading characters into.
200		* @param length The number of characters to read.
201		* @return The number of characters read or <code>-1</code>
202		* if the end of file has been reached and
203		* <code>throwEofException</code> is set to {@code false}.
204		* @throws EOFException if the end of file is reached and
205		* <code>throwEofException</code> is set to {@code true}.
206		* @throws IOException if trying to read past the end of file.
207		*/
208		@Override
209		public int read(final char[] chars, final int offset, final int length) throws IOException {
210	1048584	if (eof) {
211	1	throw new IOException("Read after end of file");
212		}
213	1048583	if (position == size) {
214	4	return doEndOfFile();
215		}
216	1048579	position += length;
217	1048579	int returnLength = length;
218	1048579	if (position > size) {
219	1	returnLength = length - (int)(position - size);
220	1	position = size;
221		}
222	1048579	processChars(chars, offset, returnLength);
223	1048579	return returnLength;
224		}
225
226		/**
227		* Reset the stream to the point when mark was last called.
228		*
229		* @throws UnsupportedOperationException if mark is not supported.
230		* @throws IOException If no position has been marked
231		* or the read limit has been exceed since the last position was
232		* marked.
233		*/
234		@Override
235		public synchronized void reset() throws IOException {
236	4	if (!markSupported) {
237	1	throw new UnsupportedOperationException("Mark not supported");
238		}
239	3	if (mark < 0) {
240	1	throw new IOException("No position has been marked");
241		}
242	2	if (position > mark + readlimit) {
243	1	throw new IOException("Marked position [" + mark +
244		"] is no longer valid - passed the read limit [" +
245		readlimit + "]");
246		}
247	1	position = mark;
248	1	eof = false;
249	1	}
250
251		/**
252		* Skip a specified number of characters.
253		*
254		* @param numberOfChars The number of characters to skip.
255		* @return The number of characters skipped or <code>-1</code>
256		* if the end of file has been reached and
257		* <code>throwEofException</code> is set to {@code false}.
258		* @throws EOFException if the end of file is reached and
259		* <code>throwEofException</code> is set to {@code true}.
260		* @throws IOException if trying to read past the end of file.
261		*/
262		@Override
263		public long skip(final long numberOfChars) throws IOException {
264	4	if (eof) {
265	1	throw new IOException("Skip after end of file");
266		}
267	3	if (position == size) {
268	1	return doEndOfFile();
269		}
270	2	position += numberOfChars;
271	2	long returnLength = numberOfChars;
272	2	if (position > size) {
273	1	returnLength = numberOfChars - (position - size);
274	1	position = size;
275		}
276	2	return returnLength;
277		}
278
279		/**
280		* Return a character value for the <code>read()</code> method.
281		* <p>
282		* This implementation returns zero.
283		*
284		* @return This implementation always returns zero.
285		*/
286		protected int processChar() {
287		// do nothing - overridable by subclass
288	0	return 0;
289		}
290
291		/**
292		* Process the characters for the <code>read(char[], offset, length)</code>
293		* method.
294		* <p>
295		* This implementation leaves the character array unchanged.
296		*
297		* @param chars The character array
298		* @param offset The offset to start at.
299		* @param length The number of characters.
300		*/
301		protected void processChars(final char[] chars, final int offset, final int length) {
302		// do nothing - overridable by subclass
303	1048576	}
304
305		/**
306		* Handle End of File.
307		*
308		* @return <code>-1</code> if <code>throwEofException</code> is
309		* set to {@code false}
310		* @throws EOFException if <code>throwEofException</code> is set
311		* to {@code true}.
312		*/
313		private int doEndOfFile() throws EOFException {
314	7	eof = true;
315	7	if (throwEofException) {
316	1	throw new EOFException();
317		}
318	6	return -1;
319		}
320
321		}