FileDocCategorySizeDatePackage
TestDocumentInputStream.javaAPI DocApache Poi 3.0.112963Mon Jan 01 12:39:44 GMT 2007org.apache.poi.poifs.filesystem

TestDocumentInputStream

public class TestDocumentInputStream extends TestCase
Class to test DocumentInputStream functionality
author
Marc Johnson

Fields Summary
private DocumentNode
_workbook
private byte[]
_workbook_data
private static final int
_workbook_size
private static final int
_buffer_size
Constructors Summary
public TestDocumentInputStream(String name)
Constructor TestDocumentInputStream

param
name
exception
IOException

        super(name);
        int blocks = (_workbook_size + 511) / 512;

        _workbook_data = new byte[ 512 * blocks ];
        Arrays.fill(_workbook_data, ( byte ) -1);
        for (int j = 0; j < _workbook_size; j++)
        {
            _workbook_data[ j ] = ( byte ) (j * j);
        }
        RawDataBlock[]       rawBlocks = new RawDataBlock[ blocks ];
        ByteArrayInputStream stream    =
            new ByteArrayInputStream(_workbook_data);

        for (int j = 0; j < blocks; j++)
        {
            rawBlocks[ j ] = new RawDataBlock(stream);
        }
        POIFSDocument document = new POIFSDocument("Workbook", rawBlocks,
                                                   _workbook_size);

        _workbook = new DocumentNode(
            document.getDocumentProperty(),
            new DirectoryNode(
                new DirectoryProperty("Root Entry"), null, null));
    
Methods Summary
public static voidmain(java.lang.String[] ignored_args)
main method to run the unit tests

param
ignored_args

        System.out.println(
            "Testing org.apache.poi.poifs.filesystem.DocumentInputStream");
        junit.textui.TestRunner.run(TestDocumentInputStream.class);
    
public voidtestAvailable()
test available() behavior

exception
IOException

        DocumentInputStream stream = new DocumentInputStream(_workbook);

        assertEquals(_workbook_size, stream.available());
        stream.close();
        try
        {
            stream.available();
            fail("Should have caught IOException");
        }
        catch (IOException ignored)
        {

            // as expected
        }
    
public voidtestBufferRead()
Test buffered read

exception
IOException

        DocumentInputStream stream = new DocumentInputStream(_workbook);

        try
        {
            stream.read(null);
            fail("Should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {

            // as expected
        }

        // test reading zero length buffer
        assertEquals(0, stream.read(new byte[ 0 ]));
        assertEquals(_workbook_size, stream.available());
        byte[] buffer = new byte[ _buffer_size ];
        int    offset = 0;

        while (stream.available() >= buffer.length)
        {
            assertEquals(_buffer_size, stream.read(buffer));
            for (int j = 0; j < buffer.length; j++)
            {
                assertEquals("in main loop, byte " + offset,
                             _workbook_data[ offset ], buffer[ j ]);
                offset++;
            }
            assertEquals("offset " + offset, _workbook_size - offset,
                         stream.available());
        }
        assertEquals(_workbook_size % _buffer_size, stream.available());
        Arrays.fill(buffer, ( byte ) 0);
        int count = stream.read(buffer);

        assertEquals(_workbook_size % _buffer_size, count);
        for (int j = 0; j < count; j++)
        {
            assertEquals("past main loop, byte " + offset,
                         _workbook_data[ offset ], buffer[ j ]);
            offset++;
        }
        assertEquals(_workbook_size, offset);
        for (int j = count; j < buffer.length; j++)
        {
            assertEquals("checking remainder, byte " + j, 0, buffer[ j ]);
        }
        assertEquals(-1, stream.read(buffer));
        stream.close();
        try
        {
            stream.read(buffer);
            fail("Should have caught IOException");
        }
        catch (IOException ignored)
        {

            // as expected
        }
    
public voidtestComplexBufferRead()
Test complex buffered read

exception
IOException

        DocumentInputStream stream = new DocumentInputStream(_workbook);

        try
        {
            stream.read(null, 0, 1);
            fail("Should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {

            // as expected
        }

        // test illegal offsets and lengths
        try
        {
            stream.read(new byte[ 5 ], -4, 0);
            fail("Should have caught IndexOutOfBoundsException");
        }
        catch (IndexOutOfBoundsException ignored)
        {

            // as expected
        }
        try
        {
            stream.read(new byte[ 5 ], 0, -4);
            fail("Should have caught IndexOutOfBoundsException");
        }
        catch (IndexOutOfBoundsException ignored)
        {

            // as expected
        }
        try
        {
            stream.read(new byte[ 5 ], 0, 6);
            fail("Should have caught IndexOutOfBoundsException");
        }
        catch (IndexOutOfBoundsException ignored)
        {

            // as expected
        }

        // test reading zero
        assertEquals(0, stream.read(new byte[ 5 ], 0, 0));
        assertEquals(_workbook_size, stream.available());
        byte[] buffer = new byte[ _workbook_size ];
        int    offset = 0;

        while (stream.available() >= _buffer_size)
        {
            Arrays.fill(buffer, ( byte ) 0);
            assertEquals(_buffer_size,
                         stream.read(buffer, offset, _buffer_size));
            for (int j = 0; j < offset; j++)
            {
                assertEquals("checking byte " + j, 0, buffer[ j ]);
            }
            for (int j = offset; j < (offset + _buffer_size); j++)
            {
                assertEquals("checking byte " + j, _workbook_data[ j ],
                             buffer[ j ]);
            }
            for (int j = offset + _buffer_size; j < buffer.length; j++)
            {
                assertEquals("checking byte " + j, 0, buffer[ j ]);
            }
            offset += _buffer_size;
            assertEquals("offset " + offset, _workbook_size - offset,
                         stream.available());
        }
        assertEquals(_workbook_size % _buffer_size, stream.available());
        Arrays.fill(buffer, ( byte ) 0);
        int count = stream.read(buffer, offset,
                                _workbook_size % _buffer_size);

        assertEquals(_workbook_size % _buffer_size, count);
        for (int j = 0; j < offset; j++)
        {
            assertEquals("checking byte " + j, 0, buffer[ j ]);
        }
        for (int j = offset; j < buffer.length; j++)
        {
            assertEquals("checking byte " + j, _workbook_data[ j ],
                         buffer[ j ]);
        }
        assertEquals(_workbook_size, offset + count);
        for (int j = count; j < offset; j++)
        {
            assertEquals("byte " + j, 0, buffer[ j ]);
        }
        assertEquals(-1, stream.read(buffer, 0, 1));
        stream.close();
        try
        {
            stream.read(buffer, 0, 1);
            fail("Should have caught IOException");
        }
        catch (IOException ignored)
        {

            // as expected
        }
    
public voidtestConstructor()
test constructor

exception
IOException


             

      
         
    
        DocumentInputStream stream = new DocumentInputStream(_workbook);

        assertEquals(_workbook_size, stream.available());
    
public voidtestMarkFunctions()
test mark/reset/markSupported.

exception
IOException

        DocumentInputStream stream = new DocumentInputStream(_workbook);
        byte[]              buffer = new byte[ _workbook_size / 5 ];

        stream.read(buffer);
        for (int j = 0; j < buffer.length; j++)
        {
            assertEquals("checking byte " + j, _workbook_data[ j ],
                         buffer[ j ]);
        }
        assertEquals(_workbook_size - buffer.length, stream.available());
        stream.reset();
        assertEquals(_workbook_size, stream.available());
        stream.read(buffer);
        stream.mark(12);
        stream.read(buffer);
        assertEquals(_workbook_size - (2 * buffer.length),
                     stream.available());
        for (int j = buffer.length; j < (2 * buffer.length); j++)
        {
            assertEquals("checking byte " + j, _workbook_data[ j ],
                         buffer[ j - buffer.length ]);
        }
        stream.reset();
        assertEquals(_workbook_size - buffer.length, stream.available());
        stream.read(buffer);
        assertEquals(_workbook_size - (2 * buffer.length),
                     stream.available());
        for (int j = buffer.length; j < (2 * buffer.length); j++)
        {
            assertEquals("checking byte " + j, _workbook_data[ j ],
                         buffer[ j - buffer.length ]);
        }
        assertTrue(stream.markSupported());
    
public voidtestReadSingleByte()
test simple read method

exception
IOException

        DocumentInputStream stream    = new DocumentInputStream(_workbook);
        int                 remaining = _workbook_size;

        for (int j = 0; j < _workbook_size; j++)
        {
	    int b = stream.read();
	    assertTrue("checking sign of " + j, b >= 0);
            assertEquals("validating byte " + j, _workbook_data[ j ],
                         ( byte ) b);
            remaining--;
            assertEquals("checking remaining after reading byte " + j,
                         remaining, stream.available());
        }
        assertEquals(-1, stream.read());
        stream.close();
        try
        {
            stream.read();
            fail("Should have caught IOException");
        }
        catch (IOException ignored)
        {

            // as expected
        }
    
public voidtestSkip()
test skip

exception
IOException

        DocumentInputStream stream = new DocumentInputStream(_workbook);

        assertEquals(_workbook_size, stream.available());
        int count = stream.available();

        while (stream.available() >= _buffer_size)
        {
            assertEquals(_buffer_size, stream.skip(_buffer_size));
            count -= _buffer_size;
            assertEquals(count, stream.available());
        }
        assertEquals(_workbook_size % _buffer_size,
                     stream.skip(_buffer_size));
        assertEquals(0, stream.available());
        stream.reset();
        assertEquals(_workbook_size, stream.available());
        assertEquals(_workbook_size, stream.skip(_workbook_size * 2));
        assertEquals(0, stream.available());
        stream.reset();
        assertEquals(_workbook_size, stream.available());
        assertEquals(_workbook_size,
                     stream.skip(2 + ( long ) Integer.MAX_VALUE));
        assertEquals(0, stream.available());