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

COVERAGE SUMMARY FOR SOURCE FILE [StructuredFileTest.java]

nameclass, %method, %block, %line, %
StructuredFileTest.java0%   (0/1)0%   (0/11)0%   (0/329)0%   (0/67)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class StructuredFileTest0%   (0/1)0%   (0/11)0%   (0/329)0%   (0/67)
StructuredFileTest (): void 0%   (0/1)0%   (0/3)0%   (0/1)
getFilledBlock (int, byte): byte [] 0%   (0/1)0%   (0/8)0%   (0/3)
getRandomBlock (int): byte [] 0%   (0/1)0%   (0/21)0%   (0/4)
runTest (): void 0%   (0/1)0%   (0/11)0%   (0/6)
setUp (): void 0%   (0/1)0%   (0/13)0%   (0/4)
tearDown (): void 0%   (0/1)0%   (0/4)0%   (0/2)
testDeleteBlocks (): void 0%   (0/1)0%   (0/13)0%   (0/3)
testGetBlockCount (): void 0%   (0/1)0%   (0/6)0%   (0/2)
testGetBlockSize (): void 0%   (0/1)0%   (0/6)0%   (0/2)
testInsertBlocks (): void 0%   (0/1)0%   (0/11)0%   (0/3)
testReadWriteBlock (): void 0%   (0/1)0%   (0/233)0%   (0/37)

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.util.Arrays;
24import junit.framework.Assert;
25import junit.framework.TestCase;
26import org.jdtaus.core.io.StructuredFile;
27 
28/**
29 * Testcase for {@code StructuredFile} implementations.
30 *
31 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
32 * @version $JDTAUS: StructuredFileTest.java 8641 2012-09-27 06:45:17Z schulte $
33 */
34public abstract class StructuredFileTest extends TestCase
35{
36    //--Constants---------------------------------------------------------------
37 
38    /** Value for property {@code blockSize} the tests are run with. */
39    public static final int BLOCK_SIZE = 1;
40 
41    /** Number of iterations to test. */
42    private static final int ITERATIONS = 20;
43 
44    /** Value to initialize new blocks with. */
45    private static final byte INIT_CHAR = ( byte ) ' ';
46 
47    //---------------------------------------------------------------Constants--
48    //--Fields------------------------------------------------------------------
49 
50    /** The implementation to test. */
51    private StructuredFile structuredFile;
52 
53    /** Expected data to read for known written data. */
54    private byte[] expectedData;
55 
56    //------------------------------------------------------------------Fields--
57    //--StructuredFileTest------------------------------------------------------
58 
59    /**
60     * Reads the contents of the {@code StructuredFile} implementation
61     * beeing tested as an array of byte.
62     *
63     * @return contents of the {@code StructuredFile} implementation beeing
64     * tested.
65     */
66    protected abstract byte[] getStructuredData();
67 
68    /**
69     * Gets a new instance of the {@code StructuredFile} implementation to test.
70     *
71     * @return a new instance of the {@code StructuredFile} implementation to
72     * test.
73     */
74    protected abstract StructuredFile getStructuredFile();
75 
76    //------------------------------------------------------StructuredFileTest--
77    //--Helpermethods-----------------------------------------------------------
78 
79    private byte[] getRandomBlock( final int size )
80    {
81        final byte[] random = new byte[ size ];
82        for ( int i = 0; i < random.length; i++ )
83        {
84            random[i] = ( byte ) ( Math.random() * 0xFF );
85        }
86 
87        return random;
88    }
89 
90    private byte[] getFilledBlock( final int size, final byte fill )
91    {
92        final byte[] filled = new byte[ size ];
93        Arrays.fill( filled, fill );
94        return filled;
95    }
96 
97    //-----------------------------------------------------------Helpermethods--
98    //--TestCase----------------------------------------------------------------
99 
100    protected void setUp() throws Exception
101    {
102        this.structuredFile = this.getStructuredFile();
103        this.expectedData = new byte[ StructuredFileTest.BLOCK_SIZE ];
104        Arrays.fill( this.expectedData, StructuredFileTest.INIT_CHAR );
105    }
106 
107    protected void tearDown() throws Exception
108    {
109        this.structuredFile = null;
110    }
111 
112    protected void runTest() throws Throwable
113    {
114        this.testGetBlockSize();
115        this.testGetBlockCount();
116        this.testInsertBlocks();
117        this.testDeleteBlocks();
118        this.testReadWriteBlock();
119    }
120 
121    //----------------------------------------------------------------TestCase--
122    //--Tests-------------------------------------------------------------------
123 
124    /**
125     * Test of getBlockSize method of class org.jdtaus.common.io.StructuredFile.
126     */
127    public void testGetBlockSize() throws Exception
128    {
129        Assert.assertEquals( StructuredFileTest.BLOCK_SIZE,
130                             this.structuredFile.getBlockSize() );
131 
132    }
133 
134    /**
135     * Test of getBlockCount method of class org.jdtaus.common.io.StructuredFile.
136     */
137    public void testGetBlockCount() throws Exception
138    {
139        Assert.assertEquals( 0L, this.structuredFile.getBlockCount() );
140    }
141 
142    /**
143     * Test of insertBlocks method of class org.jdtaus.common.io.StructuredFile.
144     */
145    public void testInsertBlocks() throws Exception
146    {
147        this.structuredFile.insertBlocks( 0L, 1 );
148        Assert.assertEquals( 1L, this.structuredFile.getBlockCount() );
149    }
150 
151    /**
152     * Test of deleteBlocks method of class org.jdtaus.common.io.StructuredFile.
153     */
154    public void testDeleteBlocks() throws Exception
155    {
156        this.structuredFile.deleteBlocks( 0L,
157                                          this.structuredFile.getBlockCount() );
158 
159        Assert.assertEquals( 0L, this.structuredFile.getBlockCount() );
160    }
161 
162    /**
163     * Test of writeBlock method of class org.jdtaus.common.io.StructuredFile.
164     */
165    public void testReadWriteBlock() throws Exception
166    {
167        final long startTime = System.currentTimeMillis();
168 
169        int i;
170        int j;
171        int written;
172        long count;
173        long insertIndex;
174        long writeIndex;
175        long maxIndex;
176        long oldBlocks;
177        byte[] filled;
178        final int blockSize = this.structuredFile.getBlockSize();
179        byte[] newExpectedData = {};
180        byte[] expectedData = {};
181        final byte[] read = new byte[ blockSize ];
182        final byte[] write = new byte[ blockSize ];
183        final byte[] initBlock = new byte[ blockSize ];
184 
185        Arrays.fill( initBlock, StructuredFileTest.INIT_CHAR );
186 
187        // Creates blocks filled with random data and checks that written
188        // data is read unchanged.
189        for ( i = 0, insertIndex = 0L; i <
190            StructuredFileTest.ITERATIONS; i++, insertIndex++ )
191        {
192 
193            count = StructuredFileTest.ITERATIONS - insertIndex;
194            maxIndex = insertIndex + count;
195            filled =
196                this.getFilledBlock( ( int ) count * blockSize, ( byte ) i );
197 
198            oldBlocks = this.structuredFile.getBlockCount();
199            this.structuredFile.insertBlocks( insertIndex, count );
200            Assert.assertEquals( oldBlocks + count,
201                                 this.structuredFile.getBlockCount() );
202 
203            // Initialize new blocks.
204            for ( j = 0; j < count; j++ )
205            {
206                this.structuredFile.writeBlock( insertIndex + j, 0,
207                                                initBlock );
208 
209            }
210            newExpectedData = new byte[ expectedData.length + filled.length ];
211            System.arraycopy( expectedData, 0, newExpectedData, 0,
212                              ( int ) ( insertIndex * blockSize ) );
213 
214            System.arraycopy( expectedData, ( int ) ( insertIndex * blockSize ),
215                              newExpectedData, ( int ) ( maxIndex * blockSize ),
216                              ( int ) ( expectedData.length - insertIndex *
217                              blockSize ) );
218 
219            Arrays.fill( newExpectedData, ( int ) ( insertIndex * blockSize ),
220                         ( int ) ( ( insertIndex + count ) * blockSize ),
221                         StructuredFileTest.INIT_CHAR );
222 
223            expectedData = newExpectedData;
224            Assert.assertEquals( true, Arrays.equals(
225                                 expectedData, this.getStructuredData() ) );
226 
227            maxIndex = insertIndex + count;
228            for ( writeIndex = insertIndex, written = 0; writeIndex < maxIndex;
229                writeIndex++, written++ )
230            {
231 
232                System.arraycopy( filled, written * blockSize, write, 0,
233                                  blockSize );
234 
235                this.structuredFile.writeBlock( writeIndex, 0, write );
236                this.structuredFile.readBlock( writeIndex, 0, read );
237                Assert.assertEquals( true, Arrays.equals( write, read ) );
238 
239                System.arraycopy( write, 0, expectedData,
240                                  ( int ) ( writeIndex * blockSize ), blockSize );
241 
242            }
243 
244            Assert.assertEquals( true, Arrays.equals(
245                                 expectedData, this.getStructuredData() ) );
246 
247        }
248 
249        Assert.assertEquals( true, Arrays.equals(
250                             expectedData, this.getStructuredData() ) );
251 
252        this.structuredFile.deleteBlocks( 0L,
253                                          this.structuredFile.getBlockCount() );
254 
255        Assert.assertTrue( this.structuredFile.getBlockCount() == 0L );
256 
257    //System.out.println("Ran " + (System.currentTimeMillis() - startTime) +
258    //    " ms.");
259 
260    }
261 
262    //-------------------------------------------------------------------Tests--
263}

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