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

Creates new TestHexDump

Parameters:

name -

 public static  void main(String[] ignored_args) 
{
        System.out.println("Testing util.HexDump functionality");
        junit.textui.TestRunner.run(TestHexDump.class);
}

main method to run the unit tests

 public  void testDump() throws IOException 
{
        byte[] testArray = new byte[ 256 ];
        for (int j = 0; j <  256; j++)
        {
            testArray[ j ] = ( byte ) j;
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 0, stream, 0);
        byte[] outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
        for (int j = 0; j <  16; j++)
        {
            int offset = (73 + HexDump.EOL.length()) * j;
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) toHex(j);
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) ' ";
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toHex(j);
                outputArray[ offset++ ] = ( byte ) toHex(k);
                outputArray[ offset++ ] = ' ";
            }
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
            }
            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
                             HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        assertEquals("array size mismatch", outputArray.length,
                     actualOutput.length);
        for (int j = 0; j <  outputArray.length; j++)
        {
            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
                         actualOutput[ j ]);
        }
        // verify proper behavior with non-zero offset
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 0x10000000, stream, 0);
        outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
        for (int j = 0; j <  16; j++)
        {
            int offset = (73 + HexDump.EOL.length()) * j;
            outputArray[ offset++ ] = ( byte ) '1";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) toHex(j);
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) ' ";
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toHex(j);
                outputArray[ offset++ ] = ( byte ) toHex(k);
                outputArray[ offset++ ] = ' ";
            }
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
            }
            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
                             HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        assertEquals("array size mismatch", outputArray.length,
                     actualOutput.length);
        for (int j = 0; j <  outputArray.length; j++)
        {
            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
                         actualOutput[ j ]);
        }
        // verify proper behavior with negative offset
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 0xFF000000, stream, 0);
        outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
        for (int j = 0; j <  16; j++)
        {
            int offset = (73 + HexDump.EOL.length()) * j;
            outputArray[ offset++ ] = ( byte ) 'F";
            outputArray[ offset++ ] = ( byte ) 'F";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) toHex(j);
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) ' ";
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toHex(j);
                outputArray[ offset++ ] = ( byte ) toHex(k);
                outputArray[ offset++ ] = ' ";
            }
            for (int k = 0; k <  16; k++)
            {
                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
            }
            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
                             HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        assertEquals("array size mismatch", outputArray.length,
                     actualOutput.length);
        for (int j = 0; j <  outputArray.length; j++)
        {
            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
                         actualOutput[ j ]);
        }
        // verify proper behavior with non-zero index
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 0x10000000, stream, 0x81);
        outputArray = new byte[ (8 * (73 + HexDump.EOL.length())) - 1 ];
        for (int j = 0; j <  8; j++)
        {
            int offset = (73 + HexDump.EOL.length()) * j;
            outputArray[ offset++ ] = ( byte ) '1";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) '0";
            outputArray[ offset++ ] = ( byte ) toHex(j + 8);
            outputArray[ offset++ ] = ( byte ) '1";
            outputArray[ offset++ ] = ( byte ) ' ";
            for (int k = 0; k <  16; k++)
            {
                int index = 0x81 + (j * 16) + k;
                if (index <  0x100)
                {
                    outputArray[ offset++ ] = ( byte ) toHex(index / 16);
                    outputArray[ offset++ ] = ( byte ) toHex(index);
                }
                else
                {
                    outputArray[ offset++ ] = ' ";
                    outputArray[ offset++ ] = ' ";
                }
                outputArray[ offset++ ] = ' ";
            }
            for (int k = 0; k <  16; k++)
            {
                int index = 0x81 + (j * 16) + k;
                if (index <  0x100)
                {
                    outputArray[ offset++ ] = ( byte ) toAscii(index);
                }
            }
            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
                             HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        assertEquals("array size mismatch", outputArray.length,
                     actualOutput.length);
        for (int j = 0; j <  outputArray.length; j++)
        {
            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
                         actualOutput[ j ]);
        }
        // verify proper behavior with negative index
        try
        {
            HexDump.dump(testArray, 0x10000000, new ByteArrayOutputStream(),
                         -1);
            fail("should have caught ArrayIndexOutOfBoundsException on negative index");
        }
        catch (ArrayIndexOutOfBoundsException ignored_exception)
        {
            // as expected
        }
        // verify proper behavior with index that is too large
        try
        {
            HexDump.dump(testArray, 0x10000000, new ByteArrayOutputStream(),
                         testArray.length);
            fail("should have caught ArrayIndexOutOfBoundsException on large index");
        }
        catch (ArrayIndexOutOfBoundsException ignored_exception)
        {
            // as expected
        }
        // verify proper behavior with null stream
        try
        {
            HexDump.dump(testArray, 0x10000000, null, 0);
            fail("should have caught IllegalArgumentException on negative index");
        }
        catch (IllegalArgumentException ignored_exception)
        {
            // as expected
        }
}

test dump method