HexDumpTest.java

package org.apache.commons.io;

import org.apache.commons.io.output.ByteArrayOutputStream;
import java.io.IOException;
import org.junit.Test;
import junit.framework.TestCase;

/** 
 * @version $Id$
 */
public class HexDumpTest extends TestCase {
    /** 
     * Creates new HexDumpTest
     * 
     * @param name
     */
public HexDumpTest(String name) {
        super(name);
    }

    private char toHex(int n) {
        char[] hexChars = new char[]{ '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' };
        return hexChars[(n % 16)];
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1739() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1739");
        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);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1740() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1740");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1741() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1741");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1742() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1742");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1743() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1743");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1744() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1744");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1745() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1745");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1746() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1746");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1747() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1747");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1748() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1748");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_add1749() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_add1749");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump");
        byte[] testArray = new byte[257];
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5874() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5874");
        byte[] testArray = new byte[128];
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5875() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5875");
        byte[] testArray = new byte[512];
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5876() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5876");
        byte[] testArray = new byte[255];
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5877() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5877");
        byte[] testArray = new byte[256];
        for (int j = 1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5878() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5878");
        byte[] testArray = new byte[256];
        for (int j = -1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5879() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5879");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5880() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5880");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 257 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5881() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5881");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 128 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5882() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5882");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 512 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5883() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5883");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 255 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5884() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5884");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 1, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5885() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5885");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -1, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5886() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5886");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5887() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5887");
        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, 1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5888() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5888");
        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, -1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5889() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5889");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5890() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5890");
        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[8 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5891() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5891");
        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[32 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5892() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5892");
        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[17 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5893() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5893");
        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[15 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5894() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5894");
        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 * (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5895() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5895");
        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 * (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5896() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5896");
        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 * (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5897() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5897");
        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 * (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5898() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5898");
        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 = 1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5899() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5899");
        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 = -1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5900() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5900");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5901() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5901");
        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 < 8 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5902() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5902");
        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 < 32 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5903() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5903");
        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 < 17 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5904() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5904");
        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 < 15 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5905() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5905");
        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 = (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5906() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5906");
        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 = (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5907() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5907");
        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 = (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5908() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5908");
        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 = (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5917() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5917");
        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 = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5918() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5918");
        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 = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5919() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5919");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5920() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5920");
        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 < 8 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5921() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5921");
        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 < 32 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5922() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5922");
        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 < 17 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5923() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5923");
        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 < 15 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5925() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5925");
        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++] = ((byte)(' '));
            }
            for (int k = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5926() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5926");
        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++] = ((byte)(' '));
            }
            for (int k = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5927() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5927");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5928() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5928");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 8 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5929() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5929");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 32 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5930() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5930");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 17 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5931() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5931");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 15 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5932() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5932");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 8) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5933() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5933");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 32) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5934() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5934");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 17) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5935() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5935");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 15) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5936() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5936");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5937() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5937");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), -1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5938() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5938");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5939() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5939");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5940() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5940");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = -1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5941() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5941");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5942() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5942");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435457, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5943() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5943");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435455, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5944() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5944");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 134217728, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5945() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5945");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 536870912, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5946() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5946");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5947() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5947");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, -1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5948() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5948");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5949() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5949");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[8 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5950() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5950");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[32 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5951() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5951");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[17 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5952() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5952");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[15 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5953() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5953");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5954() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5954");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5955() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5955");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5956() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5956");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5957() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5957");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5958() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5958");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = -1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5959() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5959");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5960() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5960");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        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)));
            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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5961() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5961");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 32 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5962() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5962");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 17 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5963() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5963");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 15 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5964() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5964");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5965() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5965");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5966() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5966");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5967() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5967");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5976() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5976");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5977() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5977");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5978() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5978");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5979() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5979");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 < 8 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5980() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5980");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 < 32 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5981() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5981");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 < 17 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5982() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5982");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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 < 15 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5984() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5984");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5985() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5985");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5986() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5986");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5987() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5987");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 8 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5988() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5988");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 32 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5989() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5989");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 17 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5990() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5990");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 15 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5991() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5991");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 8) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5992() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5992");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 32) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5993() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5993");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 17) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5994() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5994");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 15) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5995() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5995");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5996() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5996");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), -1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5997() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5997");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5998() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5998");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation5999() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation5999");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = -1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6000() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6000");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6001() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6001");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777215, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6002() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6002");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777217, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6003() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6003");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -8388608, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6004() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6004");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -33554432, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6005() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6005");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6006() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6006");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, -1);
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6007() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6007");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6008() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6008");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[8 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6009() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6009");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[32 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6010() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6010");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[17 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6011() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6011");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[15 * (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6012() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6012");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6013() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6013");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6014() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6014");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6015() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6015");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6016() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6016");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6017() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6017");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = -1 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6018() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6018");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6019() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6019");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 8 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6020() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6020");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 32 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6021() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6021");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 17 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6022() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6022");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 15 ; 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6023() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6023");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (74 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6024() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6024");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (72 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6025() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6025");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (36 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6026() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6026");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, stream, 0);
        outputArray = new byte[16 * (73 + (HexDump.EOL.length()))];
        for (int j = 0 ; j < 16 ; j++) {
            int offset = (146 + (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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6035() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6035");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6036() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6036");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6037() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6037");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6038() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6038");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 < 8 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6039() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6039");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 < 32 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6040() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6040");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 < 17 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6041() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6041");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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 < 15 ; k++) {
                outputArray[offset++] = ((byte)(toHex(j)));
                outputArray[offset++] = ((byte)(toHex(k)));
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6043() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6043");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6044() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6044");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = -1 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6045() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6045");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6046() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6046");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 8 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6047() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6047");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 32 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6048() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6048");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 17 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6049() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6049");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 15 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6050() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6050");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 8) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6051() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6051");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 32) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6052() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6052");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 17) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6053() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6053");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 15) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6054() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6054");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6055() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6055");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), -1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6056() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6056");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6057() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6057");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6058() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6058");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = -1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6059() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6059");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6060() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6060");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435457, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6061() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6061");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435455, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6062() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6062");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 134217728, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6063() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6063");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 536870912, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6064() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6064");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 130);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6065() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6065");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 128);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6066() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6066");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 64);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6067() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6067");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 258);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6068() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6068");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(4 * (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6069() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6069");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(16 * (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6070() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6070");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(9 * (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6071() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6071");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(7 * (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6072() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6072");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (74 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6073() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6073");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (72 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6074() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6074");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (36 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6075() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6075");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (146 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6076() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6076");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 2];
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6077() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6077");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 0];
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6078() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6078");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 0];
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6079() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6079");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 1 ; 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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6080() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6080");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = -1 ; 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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6081() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6081");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6082() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6082");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 4 ; 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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6083() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6083");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        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 + 8))));
            outputArray[offset++] = ((byte)('1'));
            outputArray[offset++] = ((byte)(' '));
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6084() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6084");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 9 ; 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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6085() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6085");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 7 ; 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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6086() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6086");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 8 ; j++) {
            int offset = (74 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6087() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6087");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 8 ; j++) {
            int offset = (72 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6088() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6088");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 8 ; j++) {
            int offset = (36 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6089() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6089");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        outputArray = new byte[(8 * (73 + (HexDump.EOL.length()))) - 1];
        for (int j = 0 ; j < 8 ; j++) {
            int offset = (146 + (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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6096() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6096");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 + 4))));
            outputArray[offset++] = ((byte)('1'));
            outputArray[offset++] = ((byte)(' '));
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6097() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6097");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 + 16))));
            outputArray[offset++] = ((byte)('1'));
            outputArray[offset++] = ((byte)(' '));
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6098() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6098");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 + 9))));
            outputArray[offset++] = ((byte)('1'));
            outputArray[offset++] = ((byte)(' '));
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6099() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6099");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 + 7))));
            outputArray[offset++] = ((byte)('1'));
            outputArray[offset++] = ((byte)(' '));
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6102() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6102");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = 1 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6103() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6103");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = -1 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6104() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6104");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6105() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6105");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 < 8 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6106() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6106");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 < 32 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6107() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6107");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 < 17 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6108() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6108");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 < 15 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6109() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6109");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (130 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6110() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6110");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (128 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6111() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6111");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (64 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6112() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6112");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (258 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6113() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6113");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 8)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6114() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6114");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 32)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6115() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6115");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 17)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6116() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6116");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 15)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6117() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6117");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 257) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6118() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6118");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 128) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6119() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6119");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 512) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6120() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6120");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 255) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6121() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6121");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 8))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6122() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6122");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 32))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6123() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6123");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 17))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6124() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6124");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 15))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6128() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6128");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 1 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6129() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6129");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = -1 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6130() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6130");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6131() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6131");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 8 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6132() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6132");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 32 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6133() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6133");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 17 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6134() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6134");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 15 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6135() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6135");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (130 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6136() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6136");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (128 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6137() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6137");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (64 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6138() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6138");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (258 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6139() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6139");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 8)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6140() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6140");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 32)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6141() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6141");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 17)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6142() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6142");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 15)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6143() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6143");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 257) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6144() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6144");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 128) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6145() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6145");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 512) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6146() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6146");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 255) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6147() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6147");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6148() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6148");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), -1, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6149() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6149");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6150() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6150");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6151() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6151");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = -1 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6152() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6152");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6153() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6153");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435457, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6154() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6154");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435455, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6155() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6155");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 134217728, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6156() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6156");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 536870912, new ByteArrayOutputStream(), -1);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6157() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6157");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), -2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6158() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6158");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 0);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6159() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6159");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 0);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6160() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6160");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435457, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6161() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6161");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435455, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6162() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6162");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 134217728, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6163() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6163");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 536870912, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6164() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6164");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435457, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6165() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6165");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435455, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6166() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6166");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 134217728, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6167() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6167");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 536870912, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6169() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6169");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 1);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6170() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6170");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, -1);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
public void testDump_literalMutation6171() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_literalMutation6171");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1332() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1332");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1333() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1333");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1334() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1334");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1335() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1335");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1336() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1336");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1337() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1337");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1338() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1338");
        byte[] testArray = new byte[256];
        for (int j = 0 ; j < 256 ; j++) {
            testArray[j] = ((byte)(j));
        }
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    /** 
     * test dump method
     * 
     * @exception IOException
     */
@Test(timeout = 1000)
    public void testDump_remove1339() throws IOException {
        fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDump_remove1339");
        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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        byte[] actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5040,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5041,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5042,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5043,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5044,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5045,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5046,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5047,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5048,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5049,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, -16777216, 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++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                outputArray[offset++] = ((byte)(toAscii(((j * 16) + k))));
            }
            java.lang.System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset, HexDump.EOL.getBytes().length);
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5050,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5051,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5052,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5053,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5054,actualOutput[j]);
        }
        stream = new ByteArrayOutputStream();
        HexDump.dump(testArray, 268435456, stream, 129);
        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 = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toHex((index / 16))));
                    outputArray[offset++] = ((byte)(toHex(index)));
                } else {
                    outputArray[offset++] = ((byte)(' '));
                    outputArray[offset++] = ((byte)(' '));
                }
                outputArray[offset++] = ((byte)(' '));
            }
            for (int k = 0 ; k < 16 ; k++) {
                int index = (129 + (j * 16)) + k;
                if (index < 256) {
                    outputArray[offset++] = ((byte)(toAscii(index)));
                } 
            }
        }
        actualOutput = stream.toByteArray();
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5055,outputArray.length);
        fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5056,actualOutput.length);
        for (int j = 0 ; j < (outputArray.length) ; j++) {
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5057,(("array[ " + j) + "] mismatch"));
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5058,outputArray[j]);
            fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5059,actualOutput[j]);
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), 2);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, new ByteArrayOutputStream(), testArray.length);
        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
        }
        try {
            HexDump.dump(testArray, 268435456, null, 0);
        } catch (IllegalArgumentException ignored_exception) {
        }
        fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
    }

    private char toAscii(int c) {
        char rval = '.';
        if ((c >= 32) && (c <= 126)) {
            rval = ((char)(c));
        } 
        return rval;
    }
}