public TestBlockListImpl(String name) 
{
        super(name);
}

Constructor TestBlockListImpl

Parameters:

name -

 public static  void main(String[] ignored_args) 
{
        System.out.println(
            "Testing org.apache.cocoon.poi.poifs.storage.BlockListImpl");
        junit.textui.TestRunner.run(TestBlockListImpl.class);
}

main method to run the unit tests

 public  void testFetchBlocks() throws IOException 
{
        // strategy:
        // 
        // 1. set up a single BAT block from which to construct a
        // BAT. create nonsense blocks in the raw data block list
        // corresponding to the indices in the BAT block.
        // 2. The indices will include very short documents (0 and 1
        // block in length), longer documents, and some screwed up
        // documents (one with a loop, one that will peek into
        // another document's data, one that includes an unused
        // document, one that includes a reserved (BAT) block, one
        // that includes a reserved (XBAT) block, and one that
        // points off into space somewhere
        BlockListImpl list       = new BlockListImpl();
        List          raw_blocks = new ArrayList();
        byte[]        data       = new byte[ 512 ];
        int           offset     = 0;
        LittleEndian.putInt(data, offset, -3);   // for the BAT block itself
        offset += LittleEndianConsts.INT_SIZE;
        // document 1: is at end of file already; start block = -2
        // document 2: has only one block; start block = 1
        LittleEndian.putInt(data, offset, -2);
        offset += LittleEndianConsts.INT_SIZE;
        // document 3: has a loop in it; start block = 2
        LittleEndian.putInt(data, offset, 2);
        offset += LittleEndianConsts.INT_SIZE;
        // document 4: peeks into document 2's data; start block = 3
        LittleEndian.putInt(data, offset, 4);
        offset += LittleEndianConsts.INT_SIZE;
        LittleEndian.putInt(data, offset, 1);
        offset += LittleEndianConsts.INT_SIZE;
        // document 5: includes an unused block; start block = 5
        LittleEndian.putInt(data, offset, 6);
        offset += LittleEndianConsts.INT_SIZE;
        LittleEndian.putInt(data, offset, -1);
        offset += LittleEndianConsts.INT_SIZE;
        // document 6: includes a BAT block; start block = 7
        LittleEndian.putInt(data, offset, 8);
        offset += LittleEndianConsts.INT_SIZE;
        LittleEndian.putInt(data, offset, 0);
        offset += LittleEndianConsts.INT_SIZE;
        // document 7: includes an XBAT block; start block = 9
        LittleEndian.putInt(data, offset, 10);
        offset += LittleEndianConsts.INT_SIZE;
        LittleEndian.putInt(data, offset, -4);
        offset += LittleEndianConsts.INT_SIZE;
        // document 8: goes off into space; start block = 11;
        LittleEndian.putInt(data, offset, 1000);
        offset += LittleEndianConsts.INT_SIZE;
        // document 9: no screw ups; start block = 12;
        int index = 13;
        for (; offset <  508; offset += LittleEndianConsts.INT_SIZE)
        {
            LittleEndian.putInt(data, offset, index++);
        }
        LittleEndian.putInt(data, offset, -2);
        raw_blocks.add(new RawDataBlock(new ByteArrayInputStream(data)));
        for (int j = raw_blocks.size(); j <  128; j++)
        {
            raw_blocks.add(
                new RawDataBlock(new ByteArrayInputStream(new byte[ 0 ])));
        }
        list.setBlocks(( RawDataBlock [] ) raw_blocks
            .toArray(new RawDataBlock[ 0 ]));
        int[]                blocks          =
        {
            0
        };
        BlockAllocationTable table           = new BlockAllocationTable(1,
                                                   blocks, 0, -2, list);
        int[]                start_blocks    =
        {
            -2, 1, 2, 3, 5, 7, 9, 11, 12
        };
        int[]                expected_length =
        {
            0, 1, -1, -1, -1, -1, -1, -1, 116
        };
        for (int j = 0; j <  start_blocks.length; j++)
        {
            try
            {
                ListManagedBlock[] dataBlocks =
                    list.fetchBlocks(start_blocks[ j ]);
                if (expected_length[ j ] == -1)
                {
                    fail("document " + j + " should have failed");
                }
                else
                {
                    assertEquals(expected_length[ j ], dataBlocks.length);
                }
            }
            catch (IOException e)
            {
                if (expected_length[ j ] == -1)
                {
                    // no problem, we expected a failure here
                }
                else
                {
                    throw e;
                }
            }
        }
}

Test fetchBlocks

 public  void testRemove() throws IOException 
{
        BlockListImpl  list   = new BlockListImpl();
        RawDataBlock[] blocks = new RawDataBlock[ 5 ];
        byte[]         data   = new byte[ 512 * 5 ];
        for (int j = 0; j <  5; j++)
        {
            Arrays.fill(data, j * 512, (j * 512) + 512, ( byte ) j);
        }
        ByteArrayInputStream stream = new ByteArrayInputStream(data);
        for (int j = 0; j <  5; j++)
        {
            blocks[ j ] = new RawDataBlock(stream);
        }
        list.setBlocks(blocks);
        // verify that you can't remove illegal indices
        for (int j = -2; j <  10; j++)
        {
            if ((j <  0) || (j  >= 5))
            {
                try
                {
                    list.remove(j);
                    fail("removing item " + j + " should have failed");
                }
                catch (IOException ignored)
                {
                }
            }
        }
        // verify we can safely and correctly remove all blocks
        for (int j = 0; j <  5; j++)
        {
            byte[] output = list.remove(j).getData();
            for (int k = 0; k <  512; k++)
            {
                assertEquals("testing block " + j + ", index " + k,
                             data[ (j * 512) + k ], output[ k ]);
            }
        }
        // verify that all blocks are gone
        for (int j = 0; j <  5; j++)
        {
            try
            {
                list.remove(j);
                fail("removing item " + j + " should not have succeeded");
            }
            catch (IOException ignored)
            {
            }
        }
}

test remove method

 public  void testSetBAT() throws IOException 
{
        BlockListImpl list = new BlockListImpl();
        list.setBAT(null);
        list.setBAT(new BlockAllocationTable());
        try
        {
            list.setBAT(new BlockAllocationTable());
            fail("second attempt should have failed");
        }
        catch (IOException ignored)
        {
        }
}

test setBAT

 public  void testZap() throws IOException 
{
        BlockListImpl list = new BlockListImpl();
        // verify that you can zap anything
        for (int j = -2; j <  10; j++)
        {
            list.zap(j);
        }
        RawDataBlock[] blocks = new RawDataBlock[ 5 ];
        for (int j = 0; j <  5; j++)
        {
            blocks[ j ] =
                new RawDataBlock(new ByteArrayInputStream(new byte[ 512 ]));
        }
        list.setBlocks(blocks);
        for (int j = -2; j <  10; j++)
        {
            list.zap(j);
        }
        // verify that all blocks are gone
        for (int j = 0; j <  5; j++)
        {
            try
            {
                list.remove(j);
                fail("removing item " + j + " should not have succeeded");
            }
            catch (IOException ignored)
            {
            }
        }
}

test zap method