EMMA Coverage Report (generated Wed Oct 03 04:37:30 CEST 2012)
[all classes][org.jdtaus.core.io.it]

COVERAGE SUMMARY FOR SOURCE FILE [FileOperationsTest.java]

nameclass, %method, %block, %line, %
FileOperationsTest.java0%   (0/1)0%   (0/13)0%   (0/473)0%   (0/129)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class FileOperationsTest0%   (0/1)0%   (0/13)0%   (0/473)0%   (0/129)
FileOperationsTest (): void 0%   (0/1)0%   (0/3)0%   (0/1)
assertValidTestFile (String): void 0%   (0/1)0%   (0/4)0%   (0/2)
getFileOperations (): FileOperations 0%   (0/1)0%   (0/3)0%   (0/1)
getTestFile (): InputStream 0%   (0/1)0%   (0/9)0%   (0/3)
runTest (): void 0%   (0/1)0%   (0/15)0%   (0/8)
setFileOperations (FileOperations): void 0%   (0/1)0%   (0/4)0%   (0/2)
testEndOfFile (): void 0%   (0/1)0%   (0/51)0%   (0/11)
testGetLength (): void 0%   (0/1)0%   (0/6)0%   (0/2)
testRead (): void 0%   (0/1)0%   (0/136)0%   (0/32)
testSetLength (): void 0%   (0/1)0%   (0/35)0%   (0/11)
testSetLengthUpdatesFilePointer (): void 0%   (0/1)0%   (0/30)0%   (0/10)
testWrite (): void 0%   (0/1)0%   (0/88)0%   (0/24)
testWriteBeyondIncreasesLength (): void 0%   (0/1)0%   (0/89)0%   (0/22)

1/*
2 *  jDTAUS Core Test Suite
3 *  Copyright (C) 2005 Christian Schulte
4 *  <cs@schulte.it>
5 *
6 *  This library is free software; you can redistribute it and/or
7 *  modify it under the terms of the GNU Lesser General Public
8 *  License as published by the Free Software Foundation; either
9 *  version 2.1 of the License, or any later version.
10 *
11 *  This library is distributed in the hope that it will be useful,
12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 *  Lesser General Public License for more details.
15 *
16 *  You should have received a copy of the GNU Lesser General Public
17 *  License along with this library; if not, write to the Free Software
18 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19 *
20 */
21package org.jdtaus.core.io.it;
22 
23import java.io.InputStream;
24import java.util.Arrays;
25import junit.framework.Assert;
26import junit.framework.TestCase;
27import org.jdtaus.core.io.FileOperations;
28 
29/**
30 * Testcase for {@code FileOperations} implementations.
31 *
32 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
33 * @version $JDTAUS: FileOperationsTest.java 8692 2012-10-01 14:16:57Z schulte $
34 */
35public class FileOperationsTest extends TestCase
36{
37    //--FileOperationsTest------------------------------------------------------
38 
39    /** The implementation to test. */
40    private FileOperations fileOperations;
41 
42    /**
43     * Gets the {@code FileOperations} implementation tests are performed with.
44     *
45     * @return the {@code FileOperations} implementation tests are performed
46     * with.
47     */
48    public FileOperations getFileOperations()
49    {
50        return this.fileOperations;
51    }
52 
53    /**
54     * Sets the {@code FileOperations} implementation to test.
55     *
56     * @param value the {@code FileOperations} implementation to test.
57     */
58    public final void setFileOperations( final FileOperations value )
59    {
60        this.fileOperations = value;
61    }
62 
63    /**
64     * Gets a testfile resource.
65     *
66     * @return an {@code InputStream} for reading the testfile content from.
67     */
68    protected InputStream getTestFile()
69    {
70        final InputStream ret = Thread.currentThread().getContextClassLoader().
71            getResourceAsStream( "org/jdtaus/core/io/it/testfile" );
72 
73        Assert.assertNotNull( ret );
74        return ret;
75    }
76 
77    /**
78     * Checks that a given {@code String} contains exactly the same contents
79     * as the content of {@code getTestFile()}.
80     *
81     * @throws RuntimeException if {@code testfile} does not hold the same
82     * characters than the contents of the testfile.
83     *
84     * @see #getTestFile()
85     */
86    protected void assertValidTestFile( final String testfile )
87    {
88        Assert.assertEquals( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", testfile );
89    }
90 
91    //------------------------------------------------------FileOperationsTest--
92    //--TestCase----------------------------------------------------------------
93 
94    protected void runTest() throws Throwable
95    {
96        this.testGetLength();
97        this.testSetLength();
98        this.testSetLengthUpdatesFilePointer();
99        this.testWriteBeyondIncreasesLength();
100        this.testEndOfFile();
101        this.testRead();
102        this.testWrite();
103    }
104 
105    //----------------------------------------------------------------TestCase--
106    //--Tests-------------------------------------------------------------------
107 
108    /**
109     * Tests the {@link FileOperations#getLength()} method.
110     * <p><ol>
111     * <li>Tests that the length of the provided {@code FileOperations}
112     * implementation is {@code 0}.</li></ol></p>
113     */
114    public void testGetLength() throws Exception
115    {
116        Assert.assertEquals( 0L, this.getFileOperations().getLength() );
117    }
118 
119    /**
120     * Tests the {@link FileOperations#setLength(long)} method.
121     * <p><ol>
122     * <li>Sets the length of the provided {@code FileOperations} implementation
123     * to {@code 100L} and checks that the corresponding {@code getLength()}
124     * method returns {@code 100L} afterwars.</li>
125     * <li>Sets the length of the provided {@code FileOperations} implementation
126     * to {@code 0L} and checks that the corresponding {@code getLength()}
127     * method returns {@code 0L} afterwars.</li>
128     * <li>Sets the length to a negative value and checks for an
129     * {@code IllegalArgumentException} to be thrown.</li>
130     * </ol></p>
131     */
132    public void testSetLength() throws Exception
133    {
134        final FileOperations ops = this.getFileOperations();
135        ops.setLength( 100L );
136        Assert.assertEquals( 100L, ops.getLength() );
137        ops.setLength( 0L );
138        Assert.assertEquals( 0L, ops.getLength() );
139 
140        try
141        {
142            ops.setLength( Long.MIN_VALUE );
143            throw new AssertionError( String.valueOf( Long.MIN_VALUE ) );
144        }
145        catch ( IllegalArgumentException e )
146        {
147            Assert.assertNotNull( e.getMessage() );
148            System.out.println( e.toString() );
149        }
150    }
151 
152    /**
153     * Tests the {@link FileOperations#setLength(long)} method to correctly
154     * position the file pointer on truncating the file.
155     */
156    public void testSetLengthUpdatesFilePointer() throws Exception
157    {
158        final FileOperations ops = this.getFileOperations();
159 
160        ops.setLength( 10000L );
161        ops.setFilePointer( 0L );
162        ops.setLength( 100L );
163        Assert.assertEquals( 0L, ops.getFilePointer() );
164        ops.setFilePointer( 50L );
165        ops.setLength( 10L );
166        Assert.assertEquals( 10L, ops.getFilePointer() );
167        ops.setLength( 0L );
168    }
169 
170    /**
171     * Tests the {@link FileOperations#write(byte[],int,int)} method to
172     * correctly increase the length when writing beyond the current length.
173     */
174    public void testWriteBeyondIncreasesLength() throws Exception
175    {
176        final FileOperations ops = this.getFileOperations();
177 
178        ops.setLength( 0L );
179        ops.setFilePointer( 0L );
180        ops.write( new byte[] { ( byte ) 1 }, 0, 1 );
181        Assert.assertEquals( 1L, ops.getLength() );
182        ops.setLength( 0L );
183 
184        ops.setLength( 10L );
185        ops.setFilePointer( 10L );
186        ops.write( new byte[] { ( byte ) 1 }, 0, 1 );
187        Assert.assertEquals( 11L, ops.getLength() );
188        ops.setLength( 0L );
189 
190        ops.setLength( 0L );
191        ops.setFilePointer( 0L );
192        ops.write( new byte[] {}, 0, 0 );
193        Assert.assertEquals( 0L, ops.getLength() );
194        ops.setLength( 0L );
195        ops.setFilePointer( 0L );
196 
197        ops.write( new byte[ 0 ], 0, 0 );
198        Assert.assertEquals( 0L, ops.getLength() );
199        Assert.assertEquals( 0L, ops.getFilePointer() );
200 
201        ops.setLength( 0L );
202    }
203 
204    /**
205     * Tests the {@link FileOperations#read} method.
206     * <ol>
207     * <li>Sets the length to {@code 1} and the filepointer to {@code 1} and
208     * tries to read {@code 1} byte checking for EOF.</li>
209     * </ol>
210     */
211    public void testEndOfFile() throws Exception
212    {
213        final FileOperations ops = this.getFileOperations();
214        ops.setLength( 1L );
215        ops.setFilePointer( 1L );
216 
217        Assert.assertEquals( 0, ops.read( new byte[ 0 ], 0, 0 ) );
218        Assert.assertEquals( FileOperations.EOF,
219                             ops.read( new byte[ 1 ], 0, 1 ) );
220 
221        ops.setLength( 100000L );
222        ops.setFilePointer( 100000L );
223        Assert.assertEquals( 0, ops.read( new byte[ 0 ], 0, 0 ) );
224        Assert.assertEquals( FileOperations.EOF,
225                             ops.read( new byte[ 1 ], 0, 1 ) );
226 
227        ops.setLength( 0L );
228    }
229 
230    /**
231     * Tests the {@link FileOperations#read} method.
232     * <p><ol>
233     * <li>Reads {@code 101} byte from a buffer of {@code 100} byte and checks
234     * that the method returns {@code EOF} for end of file.</li>
235     * <li>Writes some digits to the file and checks that property
236     * {@code length} matches the expected value after writing.</li>
237     * <li>Sets the file pointer to the middle of the file and reads more bytes
238     * than available in the file checking to get the expected number of read
239     * bytes returned from the method.</li>
240     * <li>Reads one more byte and checks that the method returns {@code EOF}
241     * for end of file.</li>
242     * <li>Reads all written data and checks that the read data matches the
243     * written data.</li>
244     * </ol></p>
245     */
246    public void testRead() throws Exception
247    {
248        final FileOperations ops = this.getFileOperations();
249        final byte[] digits = new byte[ 100 ]; // Muss durch 2 teilbar sein.
250        final byte[] buf = new byte[ digits.length ];
251        Arrays.fill( digits, ( byte ) '1' );
252 
253        int toRead = 0;
254        int totalRead = 0;
255        int read = 0;
256 
257        // EOF
258        Assert.assertEquals( FileOperations.EOF,
259                             ops.read( new byte[ 100 ], 0, 100 ) );
260 
261        ops.setFilePointer( 0L );
262        ops.write( digits, 0, digits.length );
263        Assert.assertEquals( digits.length, ops.getLength() );
264 
265        // Rest before EOF
266        ops.setFilePointer( digits.length / 2 );
267 
268        toRead = digits.length;
269        do
270        {
271            read = ops.read( buf, totalRead, toRead );
272            if ( read != FileOperations.EOF )
273            {
274                totalRead += read;
275                toRead -= read;
276            }
277        }
278        while ( totalRead < digits.length && read != FileOperations.EOF );
279 
280        Assert.assertEquals( digits.length / 2, totalRead );
281        Assert.assertEquals( FileOperations.EOF,
282                             ops.read( buf, buf.length - 1, 1 ) );
283 
284        // Read the written data.
285        ops.setFilePointer( 0L );
286        toRead = digits.length;
287        totalRead = 0;
288        do
289        {
290            read = ops.read( buf, totalRead, toRead );
291            if ( read != FileOperations.EOF )
292            {
293                totalRead += read;
294                toRead -= read;
295            }
296        }
297        while ( totalRead < digits.length && read != FileOperations.EOF );
298 
299        Assert.assertEquals( digits.length, totalRead );
300        Assert.assertTrue( Arrays.equals( digits, buf ) );
301        ops.setLength( 0 );
302    }
303 
304    /**
305     * Tests the {@link FileOperations#write} method.
306     * <p><ol>
307     * <li>Writes some digits to the file and checks that property
308     * {@code length} matches the expected value after writing.</li>
309     * <li>Sets the file pointer after the end of the file and writes some
310     * digits to the file checking that property {@code length} matches the
311     * expected value after writing.</li>
312     * <li>Reads the written data and checks that the read data matches the
313     * written data.</li>
314     * </ol></p>
315     */
316    public void testWrite() throws Exception
317    {
318        final long off;
319        final FileOperations ops = this.getFileOperations();
320        final byte[] digits = new byte[ 100 ]; // Muss durch 2 teilbar sein.
321        final byte[] buf = new byte[ digits.length ];
322        int totalRead = 0;
323        int toRead = 0;
324        int read = 0;
325        Arrays.fill( digits, ( byte ) '1' );
326 
327        ops.setFilePointer( 0L );
328        ops.write( digits, 0, 100 );
329        Assert.assertEquals( digits.length, ops.getLength() );
330 
331        off = ops.getLength() * 2;
332        ops.setFilePointer( off );
333        ops.write( digits, 0, 100 );
334        ops.setFilePointer( off );
335 
336        toRead = digits.length;
337        do
338        {
339            read = ops.read( buf, totalRead, toRead );
340            if ( read != FileOperations.EOF )
341            {
342                totalRead += read;
343                toRead -= read;
344            }
345        }
346        while ( totalRead < digits.length && read != FileOperations.EOF );
347        Assert.assertEquals( digits.length, totalRead );
348        Assert.assertTrue( Arrays.equals( digits, buf ) );
349        ops.setLength( 0 );
350    }
351 
352    //-------------------------------------------------------------------Tests--
353}

[all classes][org.jdtaus.core.io.it]
EMMA 2.1.5320 (stable) (C) Vladimir Roubtsov